This specification is developed on GitHub with the help of the ECMAScript community. There are a number of ways to contribute to the development of this specification:
Community:
Refer to the
This Ecma Standard defines the ECMAScript 2019 Language. It is the tenth edition of the ECMAScript Language Specification. Since publication of the first edition in 1997, ECMAScript has grown to be one of the world's most widely used general-purpose programming languages. It is best known as the language embedded in web browsers but has also been widely adopted for server and embedded applications.
ECMAScript is based on several originating technologies, the most well-known being JavaScript (Netscape) and JScript (Microsoft). The language was invented by Brendan Eich at Netscape and first appeared in that company's Navigator 2.0 browser. It has appeared in all subsequent browsers from Netscape and in all browsers from Microsoft starting with Internet Explorer 3.0.
The development of the ECMAScript Language Specification started in November 1996. The first edition of this Ecma Standard was adopted by the Ecma General Assembly of June 1997.
That Ecma Standard was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and approved as international standard ISO/IEC 16262, in April 1998. The Ecma General Assembly of June 1998 approved the second edition of ECMA-262 to keep it fully aligned with ISO/IEC 16262. Changes between the first and the second edition are editorial in nature.
The third edition of the Standard introduced powerful regular expressions, better string handling, new control statements, try/catch exception handling, tighter definition of errors, formatting for numeric output and minor changes in anticipation of future language growth. The third edition of the ECMAScript standard was adopted by the Ecma General Assembly of December 1999 and published as ISO/IEC 16262:2002 in June 2002.
After publication of the third edition, ECMAScript achieved massive adoption in conjunction with the World Wide Web where it has become the programming language that is supported by essentially all web browsers. Significant work was done to develop a fourth edition of ECMAScript. However, that work was not completed and not published as the fourth edition of ECMAScript but some of it was incorporated into the development of the sixth edition.
The fifth edition of ECMAScript (published as ECMA-262 5 th edition) codified de facto interpretations of the language specification that have become common among browser implementations and added support for new features that had emerged since the publication of the third edition. Such features include accessor properties, reflective creation and inspection of objects, program control of property attributes, additional array manipulation functions, support for the JSON object encoding format, and a strict mode that provides enhanced error checking and program security. The fifth edition was adopted by the Ecma General Assembly of December 2009.
The fifth edition was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and approved as international standard ISO/IEC 16262:2011. Edition 5.1 of the ECMAScript Standard incorporated minor corrections and is the same text as ISO/IEC 16262:2011. The 5.1 Edition was adopted by the Ecma General Assembly of June 2011.
Focused development of the sixth edition started in 2009, as the fifth edition was being prepared for publication. However, this was preceded by significant experimentation and language enhancement design efforts dating to the publication of the third edition in 1999. In a very real sense, the completion of the sixth edition is the culmination of a fifteen year effort. The goals for this addition included providing better support for large applications, library creation, and for use of ECMAScript as a compilation target for other languages. Some of its major enhancements included modules, class declarations, lexical block scoping, iterators and generators, promises for asynchronous programming, destructuring patterns, and proper tail calls. The ECMAScript library of built-ins was expanded to support additional data abstractions including maps, sets, and arrays of binary numeric values as well as additional support for Unicode supplemental characters in strings and regular expressions. The built-ins were also made extensible via subclassing. The sixth edition provides the foundation for regular, incremental language and library enhancements. The sixth edition was adopted by the General Assembly of June 2015.
ECMAScript 2016 was the first ECMAScript edition released under
Ecma TC39's new yearly release cadence and open development process. A
plain-text source document was built from the ECMAScript 2015 source
document to serve as the base for further development entirely on
GitHub. Over the year of this standard's development, hundreds of pull
requests and issues were filed representing thousands of bug fixes,
editorial fixes and other improvements. Additionally, numerous software
tools were developed to aid in this effort including Ecmarkup,
Ecmarkdown, and Grammarkdown. ES2016 also included support for a new
exponentiation operator and adds a new method to Array.prototype called
includes
.
ECMAScript 2017 introduced Async Functions, Shared Memory, and
Atomics along with smaller language and library enhancements, bug fixes,
and editorial updates. Async functions improve the asynchronous
programming experience by providing syntax for promise-returning
functions. Shared Memory and Atomics introduce a new
Object.values
,
Object.entries
, and
Object.getOwnPropertyDescriptors
.
ECMAScript 2018 introduced support for asynchronous iteration via the AsyncIterator protocol and async generators. It also included four new regular expression features: the dotAll flag, named capture groups, Unicode property escapes, and look-behind assertions. Lastly it included rest parameter and spread operator support for object properties.
This specification, the 10
th
edition, introduces a few new built-in functions:
flat
and
flatMap
on
Array.prototype
for flattening arrays,
Object.fromEntries
for directly turning the return value of
Object.entries
into a new Object, and
trimStart
and
trimEnd
on
String.prototype
as better-named alternatives to the widely implemented but non-standard
String.prototype.trimLeft
and
trimRight
built-ins. In addition, this specification includes a few minor updates
to syntax and semantics. Updated syntax includes optional catch binding
parameters and allowing U+2028 (LINE SEPARATOR) and U+2029 (PARAGRAPH
SEPARATOR) in string literals to align with JSON. Other updates include
requiring that
Array.prototype.sort
be a stable sort, requiring that JSON.stringify return well-formed UTF-8 regardless of input, and clarifying
Function.prototype.toString
by requiring that it either return the corresponding original source text or a standard placeholder.
Dozens of individuals representing many organizations have made very significant contributions within Ecma TC39 to the development of this edition and to the prior editions. In addition, a vibrant community has emerged supporting TC39's ECMAScript efforts. This community has reviewed numerous drafts, filed thousands of bug reports, performed implementation experiments, contributed test suites, and educated the world-wide developer community about ECMAScript. Unfortunately, it is impossible to identify and acknowledge every person and organization who has contributed to this effort.
Allen Wirfs-Brock
ECMA-262, Project Editor, 6
th
Edition
Brian Terlson
ECMA-262, Project Editor, 7
th
through 10
th
Editions
This Standard defines the ECMAScript 2019 general-purpose programming language.
A conforming implementation of ECMAScript must provide and support all the types, values, objects, properties, functions, and program syntax and semantics described in this specification.
A conforming implementation of ECMAScript must interpret source text input in conformance with the latest version of the Unicode Standard and ISO/IEC 10646.
A conforming implementation of ECMAScript that provides an application programming interface (API) that supports programs that need to adapt to the linguistic and cultural conventions used by different human languages and countries must implement the interface defined by the most recent edition of ECMA-402 that is compatible with this specification.
A conforming implementation of ECMAScript may provide additional types, values, objects, properties, and functions beyond those described in this specification. In particular, a conforming implementation of ECMAScript may provide properties not described in this specification, and values for those properties, for objects that are described in this specification.
A conforming implementation of ECMAScript may support program and
regular expression syntax not described in this specification. In
particular, a conforming implementation of ECMAScript may support
program syntax that makes use of the “future reserved words” listed in
subclause
A conforming implementation of ECMAScript must not implement any
extension that is listed as a Forbidden Extension in subclause
The following referenced documents are indispensable for the application of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document (including any amendments) applies.
ISO/IEC 10646 Information Technology – Universal Multiple-Octet Coded Character Set (UCS) plus Amendment 1:2005, Amendment 2:2006, Amendment 3:2008, and Amendment 4:2008 , plus additional amendments and corrigenda, or successor
ECMA-402,
ECMAScript 2015 Internationalization API Specification
.
https://ecma-international.org/publications/standards/Ecma-402.htm
ECMA-404,
The JSON Data Interchange Format
.
https://ecma-international.org/publications/standards/Ecma-404.htm
This section contains a non-normative overview of the ECMAScript language.
ECMAScript is an object-oriented programming language for performing computations and manipulating computational objects within a host environment. ECMAScript as defined here is not intended to be computationally self-sufficient; indeed, there are no provisions in this specification for input of external data or output of computed results. Instead, it is expected that the computational environment of an ECMAScript program will provide not only the objects and other facilities described in this specification but also certain environment-specific objects, whose description and behaviour are beyond the scope of this specification except to indicate that they may provide certain properties that can be accessed and certain functions that can be called from an ECMAScript program.
ECMAScript was originally designed to be used as a scripting language, but has become widely used as a general-purpose programming language. A scripting language is a programming language that is used to manipulate, customize, and automate the facilities of an existing system. In such systems, useful functionality is already available through a user interface, and the scripting language is a mechanism for exposing that functionality to program control. In this way, the existing system is said to provide a host environment of objects and facilities, which completes the capabilities of the scripting language. A scripting language is intended for use by both professional and non-professional programmers.
ECMAScript was originally designed to be a Web scripting language , providing a mechanism to enliven Web pages in browsers and to perform server computation as part of a Web-based client-server architecture. ECMAScript is now used to provide core scripting capabilities for a variety of host environments. Therefore the core language is specified in this document apart from any particular host environment.
ECMAScript usage has moved beyond simple scripting and it is now used for the full spectrum of programming tasks in many different environments and scales. As the usage of ECMAScript has expanded, so has the features and facilities it provides. ECMAScript is now a fully featured general-purpose programming language.
Some of the facilities of ECMAScript are similar to those used in other programming languages; in particular C, Java™, Self, and Scheme as described in:
ISO/IEC 9899:1996, Programming Languages – C .
Gosling, James, Bill Joy and Guy Steele. The Java ™ Language Specification . Addison Wesley Publishing Co., 1996.
Ungar, David, and Smith, Randall B. Self: The Power of Simplicity. OOPSLA '87 Conference Proceedings , pp. 227-241, Orlando, FL, October 1987.
IEEE Standard for the Scheme Programming Language . IEEE Std 1178-1990.
A web browser provides an ECMAScript host environment for client-side computation including, for instance, objects that represent windows, menus, pop-ups, dialog boxes, text areas, anchors, frames, history, cookies, and input/output. Further, the host environment provides a means to attach scripting code to events such as change of focus, page and image loading, unloading, error and abort, selection, form submission, and mouse actions. Scripting code appears within the HTML and the displayed page is a combination of user interface elements and fixed and computed text and images. The scripting code is reactive to user interaction, and there is no need for a main program.
A web server provides a different host environment for server-side computation including objects representing requests, clients, and files; and mechanisms to lock and share data. By using browser-side and server-side scripting together, it is possible to distribute computation between the client and server while providing a customized user interface for a Web-based application.
Each Web browser and server that supports ECMAScript supplies its own host environment, completing the ECMAScript execution environment.
The following is an informal overview of ECMAScript—not all parts of the language are described. This overview is not part of the standard proper.
ECMAScript is object-based: basic language and host facilities
are provided by objects, and an ECMAScript program is a cluster of
communicating objects. In ECMAScript, an
object
is a collection of zero or more
properties
each with
attributes
that determine how each property can be used—for example, when the Writable attribute for a property is set to
ECMAScript defines a collection of
built-in objects
that round out the definition of ECMAScript entities. These built-in objects include the
Object
,
Function
,
Boolean
,
Symbol
, and various
Error
objects; objects that represent and manipulate numeric values including
Math
,
Number
, and
Date
; the text processing objects
String
and
RegExp
; objects that are indexed collections of values including
Array
and nine different kinds of Typed Arrays whose elements all have a
specific numeric data representation; keyed collections including
Map
and
Set
objects; objects supporting structured data including the
JSON
object,
ArrayBuffer
,
SharedArrayBuffer
, and
DataView
; objects supporting control abstractions including generator functions and
Promise
objects; and reflection objects including
Proxy
and
Reflect
.
ECMAScript also defines a set of built-in operators . ECMAScript operators include various unary operations, multiplicative operators, additive operators, bitwise shift operators, relational operators, equality operators, binary bitwise operators, binary logical operators, assignment operators, and the comma operator.
Large ECMAScript programs are supported by modules which allow a program to be divided into multiple sequences of statements and declarations. Each module explicitly identifies declarations it uses that need to be provided by other modules and which of its declarations are available for use by other modules.
ECMAScript syntax intentionally resembles Java syntax. ECMAScript syntax is relaxed to enable it to serve as an easy-to-use scripting language. For example, a variable is not required to have its type declared nor are types associated with properties, and defined functions are not required to have their declarations appear textually before calls to them.
Even though ECMAScript includes syntax for class definitions,
ECMAScript objects are not fundamentally class-based such as those in
C++, Smalltalk, or Java. Instead objects may be created in various ways
including via a literal notation or via
constructors
which
create objects and then execute code that initializes all or part of
them by assigning initial values to their properties. Each
"prototype"
that is used to implement
prototype-based inheritance
and
shared properties
. Objects are created by using constructors in
new
expressions; for example,
new Date(2009, 11)
creates a new Date object. Invoking a
Date()
produces a string representation of the current date and time rather than an object.
Every object created by a
"prototype"
property. Furthermore, a prototype may have a non-null implicit reference to its prototype, and so on; this is called the
prototype chain
.
When a reference is made to a property in an object, that reference is
to the property of that name in the first object in the prototype chain
that contains a property of that name. In other words, first the object
mentioned directly is examined for such a property; if that object
contains the named property, that is the property to which the reference
refers; if that object does not contain the named property, the
prototype for that object is examined next; and so on.
In a class-based object-oriented language, in general, state is carried by instances, methods are carried by classes, and inheritance is only of structure and behaviour. In ECMAScript, the state and methods are carried by objects, while structure, behaviour, and state are all inherited.
All objects that do not directly contain a particular property that their prototype contains share that property and its value. Figure 1 illustrates this:
CF
is a
new
expressions:
cf
1
,
cf
2
,
cf
3
,
cf
4
, and
cf
5
. Each of these objects contains properties named
q1
and
q2
. The dashed lines represent the implicit prototype relationship; so, for example,
cf
3
's prototype is
CF
p
. The
P1
and
P2
, which are not visible to
CF
p
,
cf
1
,
cf
2
,
cf
3
,
cf
4
, or
cf
5
. The property named
CFP1
in
CF
p
is shared by
cf
1
,
cf
2
,
cf
3
,
cf
4
, and
cf
5
(but not by
CF
), as are any properties found in
CF
p
's implicit prototype chain that are not named
q1
,
q2
, or
CFP1
. Notice that there is no implicit prototype link between
CF
and
CF
p
.
Unlike most class-based object languages, properties can be added to objects dynamically by assigning values to them. That is, constructors are not required to name or assign values to all or any of the constructed object's properties. In the above diagram, one could add a new shared property for cf 1 , cf 2 , cf 3 , cf 4 , and cf 5 by assigning a new value to the property in CF p .
Although ECMAScript objects are not inherently class-based, it
is often convenient to define class-like abstractions based upon a
common pattern of
The ECMAScript Language recognizes the possibility that some users of the language may wish to restrict their usage of some features available in the language. They might do so in the interests of security, to avoid what they consider to be error-prone features, to get enhanced error checking, or for other reasons of their choosing. In support of this possibility, ECMAScript defines a strict variant of the language. The strict variant of the language excludes some specific syntactic and semantic features of the regular ECMAScript language and modifies the detailed semantics of some features. The strict variant also specifies additional error conditions that must be reported by throwing error exceptions in situations that are not specified as errors by the non-strict form of the language.
The strict variant of ECMAScript is commonly referred to as the strict mode of the language. Strict mode selection and use of the strict mode syntax and semantics of ECMAScript is explicitly made at the level of individual ECMAScript source text units. Because strict mode is selected at the level of a syntactic source text unit, strict mode only imposes restrictions that have local effect within such a source text unit. Strict mode does not restrict or modify any aspect of the ECMAScript semantics that must operate consistently across multiple source text units. A complete ECMAScript program may be composed of both strict mode and non-strict mode ECMAScript source text units. In this case, strict mode only applies when actually executing code that is defined within a strict mode source text unit.
In order to conform to this specification, an ECMAScript implementation must implement both the full unrestricted ECMAScript language and the strict variant of the ECMAScript language as defined by this specification. In addition, an implementation must support the combination of unrestricted and strict mode source text units into a single composite program.
For the purposes of this document, the following terms and definitions apply.
set of data values as defined in clause
member of one of the types Undefined, Null, Boolean, Number, Symbol, or String as defined in clause
A primitive value is a datum that is represented directly at the lowest level of the language implementation.
member of the type Object
An object is a collection of properties and has a single prototype object. The prototype may be the null value.
The value of a
prototype
property is a prototype object that is used to implement inheritance and shared properties.
object that provides shared properties for other objects
When a
prototype
property for the purpose of resolving property references. The
prototype
property can be referenced by the program expression
constructor
.prototype
,
and properties added to an object's prototype are shared, through
inheritance, by all objects sharing the prototype. Alternatively, a new
object may be created with an explicitly specified prototype by using
the
Object.create
built-in function.
object that has the default behaviour for the essential internal methods that must be supported by all objects
object that does not have the default behaviour for one or more of the essential internal methods
Any object that is not an ordinary object is an
object whose semantics are defined by this specification
object specified and supplied by an ECMAScript implementation
Standard built-in objects are defined in this specification.
An ECMAScript implementation may specify and supply additional kinds of
built-in objects. A
built-in
primitive value used when a variable has not been assigned a value
type whose sole value is the
primitive value that represents the intentional absence of any object value
type whose sole value is the
member of the Boolean type
There are only two Boolean values,
type consisting of the primitive values
member of the Object type that is an instance of the standard built-in
Boolean
A Boolean object is created by using the
Boolean
new
expression, supplying a Boolean value as an argument. The resulting
object has an internal slot whose value is the Boolean value. A Boolean
object can be coerced to a Boolean value.
primitive value that is a finite ordered sequence of zero or more 16-bit unsigned integer values
A String value is a member of the String type. Each integer value in the sequence usually represents a single 16-bit unit of UTF-16 text. However, ECMAScript does not place any restrictions or requirements on the values except that they must be 16-bit unsigned integers.
set of all possible String values
member of the Object type that is an instance of the standard built-in
String
A String object is created by using the
String
new
expression, supplying a String value as an argument. The resulting
object has an internal slot whose value is the String value. A String
object can be coerced to a String value by calling the
String
primitive value corresponding to a double-precision 64-bit binary format IEEE 754-2008 value
A Number value is a member of the Number type and is a direct representation of a number.
set of all possible Number values including the special “Not-a-Number” (NaN) value, positive infinity, and negative infinity
member of the Object type that is an instance of the standard built-in
Number
A Number object is created by using the
Number
new
expression, supplying a number value as an argument. The resulting
object has an internal slot whose value is the number value. A Number
object can be coerced to a number value by calling the
Number
number value that is the positive infinite number value
number value that is an IEEE 754-2008 “Not-a-Number” value
primitive value that represents a unique, non-String Object property key
set of all possible Symbol values
member of the Object type that is an instance of the standard built-in
Symbol
member of the Object type that may be invoked as a subroutine
In addition to its properties, a function contains executable code and state that determine how it behaves when invoked. A function's code may or may not be written in ECMAScript.
built-in object that is a function
Examples of built-in functions include
parseInt
and
Math.exp
. An implementation may provide implementation-dependent built-in functions that are not described in this specification.
part of an object that associates a key (either a String value or a Symbol value) and a value
Depending upon the form of the property the value may be
represented either directly as a data value (a primitive value, an
object, or a
function that is the value of a property
When a function is called as a method of an object, the object is passed to the function as its
method that is a built-in function
Standard built-in methods are defined in this specification, and an ECMAScript implementation may specify and provide other additional built-in methods.
internal value that defines some characteristic of a property
property that is directly contained by its object
property of an object that is not an own property but is a property (either own or inherited) of the object's prototype
The remainder of this specification is organized as follows:
Clause 5 defines the notational conventions used throughout the specification.
Clauses 6-9 define the execution environment within which ECMAScript programs operate.
Clauses 10-16 define the actual ECMAScript programming language including its syntactic encoding and the execution semantics of all language features.
Clauses 17-26 define the ECMAScript standard library. They include the definitions of all of the standard objects that are available for use by ECMAScript programs as they execute.
Clause 27 describes the memory consistency model of accesses on SharedArrayBuffer-backed memory and methods of the Atomics object.
A context-free grammar consists of a number of productions . Each production has an abstract symbol called a nonterminal as its left-hand side , and a sequence of zero or more nonterminal and terminal symbols as its right-hand side . For each grammar, the terminal symbols are drawn from a specified alphabet.
A chain production is a production that has exactly one nonterminal symbol on its right-hand side along with zero or more terminal symbols.
Starting from a sentence consisting of a single distinguished nonterminal, called the goal symbol , a given context-free grammar specifies a language , namely, the (perhaps infinite) set of possible sequences of terminal symbols that can result from repeatedly replacing any nonterminal in the sequence with a right-hand side of a production for which the nonterminal is the left-hand side.
A
lexical grammar
for ECMAScript is given in clause
Input elements other than white space and comments form the
terminal symbols for the syntactic grammar for ECMAScript and are called
ECMAScript
tokens
. These tokens are the reserved words,
identifiers, literals, and punctuators of the ECMAScript language.
Moreover, line terminators, although not considered to be tokens, also
become part of the stream of input elements and guide the process of
automatic semicolon insertion (
/*
…
*/
regardless of whether it spans more than one line) is likewise simply discarded if it contains no line terminator; but if a
A
RegExp grammar
for ECMAScript is given in
Productions of the lexical and RegExp grammars are distinguished by having two colons “ :: ” as separating punctuation. The lexical and RegExp grammars share some productions.
Another grammar is used for translating Strings into numeric
values. This grammar is similar to the part of the lexical grammar
having to do with numeric literals and has as its terminal symbols
Productions of the numeric string grammar are distinguished by having three colons “ ::: ” as punctuation.
The
syntactic grammar
for ECMAScript is given in
clauses 11, 12, 13, 14, and 15. This grammar has ECMAScript tokens
defined by the lexical grammar as its terminal symbols (
When a stream of code points is to be parsed as an ECMAScript
When a parse is successful, it constructs a
parse tree
, a rooted tree structure in which each node is a
Parse Node
. Each Parse Node is an
instance
of a symbol in the grammar; it represents a span of the source text
that can be derived from that symbol. The root node of the parse tree,
representing the whole of the source text, is an instance of the parse's
New Parse Nodes are instantiated for each invocation of the parser and never reused between parses even of identical source text. Parse Nodes are considered the same Parse Node if and only if they represent the same span of source text, are instances of the same grammar symbol, and resulted from the same parser invocation.
Parsing the same String multiple times will lead to different Parse Nodes, e.g., as occurs in:
eval(str); eval(str);
Productions of the syntactic grammar are distinguished by having just one colon “ : ” as punctuation.
The syntactic grammar as presented in clauses 12, 13, 14 and 15
is not a complete account of which token sequences are accepted as a
correct ECMAScript
In certain cases, in order to avoid ambiguities, the syntactic
grammar uses generalized productions that permit token sequences that do
not form a valid ECMAScript
Terminal symbols of the lexical, RegExp, and numeric string grammars are shown in
fixed width
font, both in the productions of the grammars and throughout this
specification whenever the text directly refers to such a terminal
symbol. These are to appear in a script exactly as written. All terminal
symbol code points specified in this way are to be understood as the
appropriate Unicode code points from the Basic Latin range, as opposed
to any similar-looking code points from other Unicode ranges.
Nonterminal symbols are shown in italic type. The definition of a nonterminal (also called a “production”) is introduced by the name of the nonterminal being defined followed by one or more colons. (The number of colons indicates to which grammar the production belongs.) One or more alternative right-hand sides for the nonterminal then follow on succeeding lines. For example, the syntactic definition:
states that the nonterminal
while
, followed by a left parenthesis token, followed by an
states that an
The subscripted suffix “ opt ”, which may appear after a terminal or nonterminal, indicates an optional symbol. The alternative containing the optional symbol actually specifies two right-hand sides, one that omits the optional element and one that includes it. This means that:
is a convenient abbreviation for:
and that:
is a convenient abbreviation for:
which in turn is an abbreviation for:
so, in this example, the nonterminal
A production may be parameterized by a subscripted annotation of the form “ [parameters] ”, which may appear as a suffix to the nonterminal symbol defined by the production. “ parameters ” may be either a single name or a comma separated list of names. A parameterized production is shorthand for a set of productions defining all combinations of the parameter names, preceded by an underscore, appended to the parameterized nonterminal symbol. This means that:
is a convenient abbreviation for:
and that:
is an abbreviation for:
Multiple parameters produce a combinatory number of productions, not all of which are necessarily referenced in a complete grammar.
References to nonterminals on the right-hand side of a production can also be parameterized. For example:
is equivalent to saying:
and:
is equivalent to:
A nonterminal reference may have both a parameter list and an “ opt ” suffix. For example:
is an abbreviation for:
Prefixing a parameter name with “ ? ” on a right-hand side nonterminal reference makes that parameter value dependent upon the occurrence of the parameter name on the reference to the current production's left-hand side symbol. For example:
is an abbreviation for:
If a right-hand side alternative is prefixed with “[+parameter]” that alternative is only available if the named parameter was used in referencing the production's nonterminal symbol. If a right-hand side alternative is prefixed with “[~parameter]” that alternative is only available if the named parameter was not used in referencing the production's nonterminal symbol. This means that:
is an abbreviation for:
and that:
is an abbreviation for:
When the words “ one of ” follow the colon(s) in a grammar definition, they signify that each of the terminal symbols on the following line or lines is an alternative definition. For example, the lexical grammar for ECMAScript contains the production:
which is merely a convenient abbreviation for:
If the phrase “[empty]” appears as the right-hand side of a production, it indicates that the production's right-hand side contains no terminals or nonterminals.
If the phrase “[lookahead ∉ set ]” appears in the right-hand side of a production, it indicates that the production may not be used if the immediately following input token sequence is a member of the given set . The set can be written as a comma separated list of one or two element terminal sequences enclosed in curly brackets. For convenience, the set can also be written as a nonterminal, in which case it represents the set of all terminals to which that nonterminal could expand. If the set consists of a single terminal the phrase “[lookahead ≠ terminal ]” may be used.
For example, given the definitions:
the definition:
matches either the letter
n
followed by one or more decimal digits the first of which is even, or a decimal digit not followed by another decimal digit.
Similarly, if the phrase “[lookahead ∈ set ]” appears in the right-hand side of a production, it indicates that the production may only be used if the immediately following input token sequence is a member of the given set . If the set consists of a single terminal the phrase “[lookahead = terminal ]” may be used.
If the phrase “[no
indicates that the production may not be used if a
throw
token and the
Unless the presence of a
When an alternative in a production of the lexical grammar or the numeric string grammar appears to be a multi-code point token, it represents the sequence of code points that would make up such a token.
The right-hand side of a production may specify that certain expansions are not permitted by using the phrase “ but not ” and then indicating the expansions to be excluded. For example, the production:
means that the nonterminal
Finally, a few nonterminal symbols are described by a descriptive phrase in sans-serif type in cases where it would be impractical to list all the alternatives:
The specification often uses a numbered list to specify steps in an algorithm. These algorithms are used to precisely specify the required semantics of ECMAScript language constructs. The algorithms are not intended to imply the use of any specific implementation technique. In practice, there may be more efficient algorithms available to implement a given feature.
Algorithms may be explicitly parameterized, in which case the names and usage of the parameters must be provided as part of the algorithm's definition.
Algorithm steps may be subdivided into sequential substeps. Substeps are indented and may themselves be further divided into indented substeps. Outline numbering conventions are used to identify substeps with the first level of substeps labelled with lower case alphabetic characters and the second level of substeps labelled with lower case roman numerals. If more than three levels are required these rules repeat with the fourth level using numeric labels. For example:
A step or substep may be written as an “if” predicate that conditions its substeps. In this case, the substeps are only applied if the predicate is true. If a step or substep begins with the word “else”, it is a predicate that is the negation of the preceding “if” predicate step at the same level.
A step may specify the iterative application of its substeps.
A step that begins with “ Assert :” asserts an invariant condition of its algorithm. Such assertions are used to make explicit algorithmic invariants that would otherwise be implicit. Such assertions add no additional semantic requirements and hence need not be checked by an implementation. They are used simply to clarify algorithms.
Algorithm steps may declare named aliases for any value using the form “Let x be someValue ”. These aliases are reference-like in that both x and someValue refer to the same underlying data and modifications to either are visible to both. Algorithm steps that want to avoid this reference-like behaviour should explicitly make a copy of the right-hand side: “Let x be a copy of someValue ” creates a shallow copy of someValue .
Once declared, an alias may be referenced in any subsequent steps and must not be referenced from steps prior to the alias's declaration. Aliases may be modified using the form “Set x to someOtherValue ”.
In order to facilitate their use in multiple parts of this specification, some algorithms, called abstract operations , are named and written in parameterized functional form so that they may be referenced by name from within other algorithms. Abstract operations are typically referenced using a functional application style such as OperationName( arg1 , arg2 ). Some abstract operations are treated as polymorphically dispatched methods of class-like specification abstractions. Such method-like abstract operations are typically referenced using a method application style such as someValue .OperationName( arg1 , arg2 ).
A syntax-directed operation is a named operation whose definition consists of algorithms, each of which is associated with one or more productions from one of the ECMAScript grammars. A production that has multiple alternative definitions will typically have a distinct algorithm for each alternative. When an algorithm is associated with a grammar production, it may reference the terminal and nonterminal symbols of the production alternative as if they were parameters of the algorithm. When used in this manner, nonterminal symbols refer to the actual alternative definition that is matched when parsing the source text. The source text matched by a grammar production is the portion of the source text that starts at the beginning of the first terminal that participated in the match and ends at the end of the last terminal that participated in the match.
When an algorithm is associated with a production alternative, the alternative is typically shown without any “[ ]” grammar annotations. Such annotations should only affect the syntactic recognition of the alternative and have no effect on the associated semantics for the alternative.
Syntax-directed operations are invoked with a parse node and, optionally, other parameters by using the conventions on steps 1, 3, and 4 in the following algorithm:
"value"
as the argument.
Unless explicitly specified otherwise, all chain productions
have an implicit definition for every operation that might be applied to
that production's left-hand side nonterminal. The implicit definition
simply reapplies the same operation with the same parameters, if any, to
the
but the Evaluation operation does not associate an algorithm with that production. In that case, the Evaluation operation implicitly includes an association of the form:
Runtime Semantics: Evaluation
Algorithms which specify semantics that must be called at runtime are called
runtime semantics
. Runtime semantics are defined by
The algorithms of this specification often implicitly return
"Infinity"
.
means the same thing as:
"Infinity"
).
However, if the value expression of a “return” statement is a
The abstract operation
A “return” statement without a value in an algorithm step means the same thing as:
Any reference to a
Algorithms steps that say to throw an exception, such as
mean the same things as:
Algorithms steps that say or are otherwise equivalent to:
mean the same thing as:
Algorithms steps that say or are otherwise equivalent to:
mean the same thing as:
Where hygienicTemp is ephemeral and visible only in the steps pertaining to ReturnIfAbrupt.
Algorithms steps that say or are otherwise equivalent to:
mean the same thing as:
Invocations of
?
indicate that
is equivalent to the following step:
Similarly, for method application style, the step:
is equivalent to:
Similarly, prefix
!
is used to indicate that the following invocation of an abstract or syntax-directed operation will never return an
is equivalent to the following steps:
Syntax-directed operations for
!
or
?
before the invocation of the operation:
Context-free grammars are not sufficiently powerful to express
all the rules that define whether a stream of input elements form a
valid ECMAScript
Static Semantic Rules have names and typically are defined using an algorithm. Named Static Semantic Rules are associated with grammar productions and a production that has multiple alternative definitions will typically have for each alternative a distinct algorithm for each applicable named static semantic rule.
Unless otherwise specified every grammar production alternative in this specification implicitly has a definition for a static semantic rule named Contains which takes an argument named symbol whose value is a terminal or nonterminal of the grammar that includes the associated production. The default definition of Contains is:
The above definition is explicitly over-ridden for specific productions.
A special kind of static semantic rule is an
Early Error Rule
.
Mathematical operations such as addition, subtraction,
negation, multiplication, division, and the mathematical functions
defined later in this clause should always be understood as computing
exact mathematical results on mathematical real numbers, which unless
otherwise noted do not include infinities and do not include a negative
zero that is distinguished from positive zero. Algorithms in this
standard that model floating-point arithmetic include explicit steps,
where necessary, to handle infinities and signed zero and to perform
rounding. If a mathematical operation or function is applied to a
floating-point number, it should be understood as being applied to the
exact mathematical value represented by that floating-point number; such
a floating-point number must be finite, and if it is
The mathematical function
The mathematical function
The notation “
The mathematical function
Algorithms within this specification manipulate values each of which has an associated type. The possible value types are exactly those defined in this clause. Types are further subclassified into ECMAScript language types and specification types.
Within this specification, the notation “Type( x )” is used as shorthand for “the type of x ” where “type” refers to the ECMAScript language and specification types defined in this clause. When the term “empty” is used as if it was naming a value, it is equivalent to saying “no value of any type”.
An ECMAScript language type corresponds to values that are directly manipulated by an ECMAScript programmer using the ECMAScript language. The ECMAScript language types are Undefined, Null, Boolean, String, Symbol, Number, and Object. An ECMAScript language value is a value that is characterized by an ECMAScript language type.
The Undefined type has exactly one value, called
The Null type has exactly one value, called
The Boolean type represents a logical entity having two values, called
The String type is the set of all ordered sequences of zero or more 16-bit unsigned integer values (“elements”) up to a maximum length of 2 53 - 1 elements. The String type is generally used to represent textual data in a running ECMAScript program, in which case each element in the String is treated as a UTF-16 code unit value. Each element is regarded as occupying a position within the sequence. These positions are indexed with nonnegative integers. The first element (if any) is at index 0, the next element (if any) at index 1, and so on. The length of a String is the number of elements (i.e., 16-bit values) within it. The empty String has length zero and therefore contains no elements.
ECMAScript operations that do not interpret String contents apply no further semantics. Operations that do interpret String values treat each element as a single UTF-16 code unit. However, ECMAScript does not restrict the value of or relationships between these code units, so operations that further interpret String contents as sequences of Unicode code points encoded in UTF-16 must account for ill-formed subsequences. Such operations apply special treatment to every code unit with a numeric value in the inclusive range 0xD800 to 0xDBFF (defined by the Unicode Standard as a leading surrogate , or more formally as a high-surrogate code unit ) and every code unit with a numeric value in the inclusive range 0xDC00 to 0xDFFF (defined as a trailing surrogate , or more formally as a low-surrogate code unit ) using the following rules:
The function
String.prototype.normalize
(see
String.prototype.localeCompare
(see
The rationale behind this design was to keep the implementation of Strings as simple and high-performing as possible. If ECMAScript source text is in Normalized Form C, string literals are guaranteed to also be normalized, as long as they do not contain any Unicode escape sequences.
In this specification, the phrase "the string-concatenation of A , B , ..." (where each argument is a String value, a code unit, or a sequence of code units) denotes the String value whose sequence of code units is the concatenation of the code units (in order) of each of the arguments (in order).
The Symbol type is the set of all non-String values that may be used as the key of an Object property (
Each possible Symbol value is unique and immutable.
Each Symbol value immutably holds an associated value called [[Description]] that is either
Well-known symbols are built-in Symbol values that are
explicitly referenced by algorithms of this specification. They are
typically used as the keys of properties whose values serve as extension
points of a specification algorithm. Unless otherwise specified,
well-known symbols values are shared by all realms (
Within this specification a well-known symbol is referred to
by using a notation of the form @@name, where “name” is one of the
values listed in
| Specification Name | [[Description]] | Value and Purpose |
|---|---|---|
| @@asyncIterator |
"Symbol.asyncIterator"
|
A method that returns the default AsyncIterator for an object. Called by the semantics of the
for
-
await
-
of
statement.
|
| @@hasInstance |
"Symbol.hasInstance"
|
A method that determines if a
instanceof
operator.
|
| @@isConcatSpreadable |
"Symbol.isConcatSpreadable"
|
A Boolean valued property that if true indicates that an object should be flattened to its array elements by
Array.prototype.concat
|
| @@iterator |
"Symbol.iterator"
|
A method that returns the default Iterator for an object. Called by the semantics of the for-of statement. |
| @@match |
"Symbol.match"
|
A regular expression method that matches the regular expression against a string. Called by the
String.prototype.match
|
| @@replace |
"Symbol.replace"
|
A regular expression method that replaces matched substrings of a string. Called by the
String.prototype.replace
|
| @@search |
"Symbol.search"
|
A regular expression method that returns the index
within a string that matches the regular expression. Called by the
String.prototype.search
|
| @@species |
"Symbol.species"
|
A function valued property that is the
|
| @@split |
"Symbol.split"
|
A regular expression method that splits a string at the
indices that match the regular expression. Called by the
String.prototype.split
|
| @@toPrimitive |
"Symbol.toPrimitive"
|
A method that converts an object to a corresponding primitive value. Called by the
|
| @@toStringTag |
"Symbol.toStringTag"
|
A String valued property that is used in the creation of
the default string description of an object. Accessed by the built-in
method
Object.prototype.toString
|
| @@unscopables |
"Symbol.unscopables"
|
An object valued property whose own and inherited property names are property names that are excluded from the
with
environment bindings of the associated object.
|
The Number type has exactly 18437736874454810627 (that is,
NaN
.)
In some implementations, external code might be able to detect a
difference between various Not-a-Number values, but such behaviour is
implementation-dependent; to ECMAScript code, all
There are two other special values, called
+Infinity
(or simply
Infinity
) and
-Infinity
.)
The other 18437736874454810624 (that is,
Note that there is both a
+0
(or simply
0
) and
-0
.)
The 18437736874454810622 (that is,
18428729675200069632 (that is,
where s is +1 or -1, m is a positive integer less than 2 53 but not less than 2 52 , and e is an integer ranging from -1074 to 971, inclusive.
The remaining 9007199254740990 (that is,
where s is +1 or -1, m is a positive integer less than 2 52 , and e is -1074.
Note that all the positive and negative integers whose magnitude is no greater than 2
53
are representable in the Number type (indeed, the integer 0 has two representations,
A finite number has an odd significand if it is nonzero and the integer m used to express it (in one of the two forms shown above) is odd. Otherwise, it has an even significand .
In this specification, the phrase “the Number value for
x
” where
x
represents an exact real mathematical quantity (which might even be an
irrational number such as π) means a Number value chosen in the
following manner. Consider the set of all finite values of the Number
type, with
Some ECMAScript operators deal only with integers in specific ranges such as
An Object is logically a collection of properties. Each property is either a data property, or an accessor property:
Properties are identified using key values. A property key value is either an ECMAScript String value or a Symbol value. All String and Symbol values, including the empty string, are valid as property keys. A property name is a property key that is a String value.
An
integer index
is a String-valued property key that is a canonical numeric String (see
Property keys are used to access properties and their values. There are two kinds of access for properties: get and set , corresponding to value retrieval and assignment, respectively. The properties accessible via get and set access includes both own properties that are a direct part of an object and inherited properties which are provided by another associated object via a property inheritance relationship. Inherited properties may be either own or inherited properties of the associated object. Each own property of an object must each have a key value that is distinct from the key values of the other own properties of that object.
All objects are logically collections of properties, but there are multiple forms of objects that differ in their semantics for accessing and manipulating their properties. Ordinary objects are the most common form of objects and have the default object semantics. An exotic object is any form of object whose property semantics differ in any way from the default semantics.
Attributes are used in this specification to define and explain the state of Object properties. A
| Attribute Name | Value Domain | Description |
|---|---|---|
| [[Value]] |
Any
|
The value retrieved by a get access of the property. |
| [[Writable]] | Boolean |
If
|
| [[Enumerable]] | Boolean |
If
|
| [[Configurable]] | Boolean |
If
|
An
| Attribute Name | Value Domain | Description |
|---|---|---|
| [[Get]] | Object | Undefined |
If the value is an Object it must be a
|
| [[Set]] | Object | Undefined |
If the value is an Object it must be a
|
| [[Enumerable]] | Boolean |
If
|
| [[Configurable]] | Boolean |
If
|
If the initial values of a property's attributes are not
explicitly specified by this specification, the default value defined in
| Attribute Name | Default Value |
|---|---|
| [[Value]] |
|
| [[Get]] |
|
| [[Set]] |
|
| [[Writable]] |
|
| [[Enumerable]] |
|
| [[Configurable]] |
|
The actual semantics of objects, in ECMAScript, are specified via algorithms called internal methods . Each object in an ECMAScript engine is associated with a set of internal methods that defines its runtime behaviour. These internal methods are not part of the ECMAScript language. They are defined by this specification purely for expository purposes. However, each object within an implementation of ECMAScript must behave as specified by the internal methods associated with it. The exact manner in which this is accomplished is determined by the implementation.
Internal method names are polymorphic. This means that
different object values may perform different algorithms when a common
internal method name is invoked upon them. That actual object upon which
an internal method is invoked is the “target” of the invocation. If, at
runtime, the implementation of an algorithm attempts to use an internal
method of an object that the object does not support, a
Internal slots correspond to internal state that is
associated with objects and used by various ECMAScript specification
algorithms. Internal slots are not object properties and they are not
inherited. Depending upon the specific internal slot specification, such
state may consist of values of any
Internal methods and internal slots are identified within this specification using names enclosed in double square brackets [[ ]].
The “Signature” column of
| Internal Method | Signature | Description |
|---|---|---|
| [[GetPrototypeOf]] | ( ) → Object | Null |
Determine the object that provides inherited properties for this object. A
|
| [[SetPrototypeOf]] | (Object | Null) → Boolean |
Associate this object with another object that provides inherited properties. Passing
|
| [[IsExtensible]] | ( ) → Boolean | Determine whether it is permitted to add additional properties to this object. |
| [[PreventExtensions]] | ( ) → Boolean |
Control whether new properties may be added to this object. Returns
|
| [[GetOwnProperty]] |
(
propertyKey
)
→
Undefined |
|
Return a
|
| [[DefineOwnProperty]] | ( propertyKey , PropertyDescriptor ) → Boolean |
Create or alter the own property, whose key is
propertyKey
, to have the state described by
PropertyDescriptor
. Return
|
| [[HasProperty]] | ( propertyKey ) → Boolean | Return a Boolean value indicating whether this object already has either an own or inherited property whose key is propertyKey . |
| [[Get]] | ( propertyKey , Receiver ) → any |
Return the value of the property whose key is
propertyKey
from this object. If any ECMAScript code must be executed to retrieve the property value,
Receiver
is used as the
|
| [[Set]] | ( propertyKey , value , Receiver ) → Boolean |
Set the value of the property whose key is
propertyKey
to
value
. If any ECMAScript code must be executed to set the property value,
Receiver
is used as the
|
| [[Delete]] | ( propertyKey ) → Boolean |
Remove the own property whose key is
propertyKey
from this object. Return
|
| [[OwnPropertyKeys]] |
( )
→
|
Return a
|
| Internal Method | Signature | Description |
|---|---|---|
| [[Call]] |
(
any
, a
|
Executes code associated with this object. Invoked via a
function call expression. The arguments to the internal method are a
|
| [[Construct]] |
(a
|
Creates an object. Invoked via the
new
or
super
operators. The first argument to the internal method is a list
containing the arguments of the operator. The second argument is the
object to which the
new
operator was initially applied. Objects that implement this internal method are called
constructors
. A
|
The semantics of the essential internal methods for ordinary objects and standard exotic objects are specified in clause
The Internal Methods of Objects of an ECMAScript engine must conform to the list of invariants specified below. Ordinary ECMAScript Objects as well as all standard exotic objects in this specification maintain these invariants. ECMAScript Proxy objects maintain these invariants by means of runtime checks on the result of traps invoked on the [[ProxyHandler]] object.
Any implementation provided exotic objects must also maintain these invariants for those objects. Violation of these invariants may cause ECMAScript code to have unpredictable behaviour and create security issues. However, violation of these invariants must never compromise the memory safety of an implementation.
An implementation must not allow these invariants to be circumvented in any manner such as by providing alternative interfaces that implement the functionality of the essential internal methods without enforcing their invariants.
An object's prototype chain should have finite length (that
is, starting from any object, recursively applying the
[[GetPrototypeOf]] internal method to its result should eventually lead
to the value
As a consequence of the third invariant, if a property is described as a
Well-known intrinsics are built-in objects that are
explicitly referenced by the algorithms of this specification and which
usually have
Within this specification a reference such as %name% means the intrinsic object, associated with the current
| Intrinsic Name | Global Name | ECMAScript Language Association |
|---|---|---|
|
|
Array
|
The
Array
|
|
|
ArrayBuffer
|
The
ArrayBuffer
|
|
|
ArrayBuffer.prototype
|
The initial value of the
prototype
|
|
|
The prototype of Array iterator objects (
|
|
|
|
Array.prototype
|
The initial value of the
prototype
|
|
|
Array.prototype.entries
|
The initial value of the
entries
|
|
|
Array.prototype.forEach
|
The initial value of the
forEach
|
|
|
Array.prototype.keys
|
The initial value of the
keys
|
|
|
Array.prototype.values
|
The initial value of the
values
|
|
|
The prototype of async-from-sync iterator objects (
|
|
|
|
The
|
|
|
|
The initial value of the
prototype
|
|
|
|
The initial value of the
prototype
property of
|
|
|
|
The
|
|
|
|
The initial value of the
prototype
property of
|
|
|
|
An object that all standard built-in async iterator objects indirectly inherit from | |
|
|
Atomics
|
The
Atomics
object (
|
|
|
Boolean
|
The
Boolean
|
|
|
Boolean.prototype
|
The initial value of the
prototype
|
|
|
DataView
|
The
DataView
|
|
|
DataView.prototype
|
The initial value of the
prototype
|
|
|
Date
|
The
Date
|
|
|
Date.prototype
|
The initial value of the
prototype
|
|
|
decodeURI
|
The
decodeURI
function (
|
|
|
decodeURIComponent
|
The
decodeURIComponent
function (
|
|
|
encodeURI
|
The
encodeURI
function (
|
|
|
encodeURIComponent
|
The
encodeURIComponent
function (
|
|
|
Error
|
The
Error
|
|
|
Error.prototype
|
The initial value of the
prototype
|
|
|
eval
|
The
eval
function (
|
| %EvalError% |
EvalError
|
The
EvalError
|
| %EvalErrorPrototype% |
EvalError.prototype
|
The initial value of the
prototype
|
| %Float32Array% |
Float32Array
|
The
Float32Array
|
| %Float32ArrayPrototype% |
Float32Array.prototype
|
The initial value of the
prototype
|
| %Float64Array% |
Float64Array
|
The
Float64Array
|
| %Float64ArrayPrototype% |
Float64Array.prototype
|
The initial value of the
prototype
|
|
|
Function
|
The
Function
|
|
|
Function.prototype
|
The initial value of the
prototype
|
|
|
The initial value of the
prototype
|
|
|
|
The
|
|
|
|
The initial value of the
prototype
|
|
| %Int8Array% |
Int8Array
|
The
Int8Array
|
| %Int8ArrayPrototype% |
Int8Array.prototype
|
The initial value of the
prototype
|
| %Int16Array% |
Int16Array
|
The
Int16Array
|
| %Int16ArrayPrototype% |
Int16Array.prototype
|
The initial value of the
prototype
|
| %Int32Array% |
Int32Array
|
The
Int32Array
|
| %Int32ArrayPrototype% |
Int32Array.prototype
|
The initial value of the
prototype
|
|
|
isFinite
|
The
isFinite
function (
|
|
|
isNaN
|
The
isNaN
function (
|
|
|
An object that all standard built-in iterator objects indirectly inherit from | |
|
|
JSON
|
The
JSON
object (
|
|
|
JSON.parse
|
The initial value of the
parse
|
| %JSONStringify% |
JSON.stringify
|
The initial value of the
stringify
|
|
|
Map
|
The
Map
|
|
|
The prototype of Map iterator objects (
|
|
|
|
Map.prototype
|
The initial value of the
prototype
|
|
|
Math
|
The
Math
object (
|
|
|
Number
|
The
Number
|
|
|
Number.prototype
|
The initial value of the
prototype
|
|
|
Object
|
The
Object
|
|
|
Object.prototype
|
The initial value of the
prototype
|
|
|
Object.prototype.toString
|
The initial value of the
toString
|
|
|
Object.prototype.valueOf
|
The initial value of the
valueOf
|
|
|
parseFloat
|
The
parseFloat
function (
|
|
|
parseInt
|
The
parseInt
function (
|
|
|
Promise
|
The
Promise
|
|
|
Promise.prototype
|
The initial value of the
prototype
|
|
|
Promise.prototype.then
|
The initial value of the
then
|
|
|
Promise.all
|
The initial value of the
all
|
|
|
Promise.reject
|
The initial value of the
reject
|
|
|
Promise.resolve
|
The initial value of the
resolve
|
|
|
Proxy
|
The
Proxy
|
| %RangeError% |
RangeError
|
The
RangeError
|
| %RangeErrorPrototype% |
RangeError.prototype
|
The initial value of the
prototype
|
| %ReferenceError% |
ReferenceError
|
The
ReferenceError
|
| %ReferenceErrorPrototype% |
ReferenceError.prototype
|
The initial value of the
prototype
|
|
|
Reflect
|
The
Reflect
object (
|
|
|
RegExp
|
The
RegExp
|
|
|
RegExp.prototype
|
The initial value of the
prototype
|
|
|
Set
|
The
Set
|
|
|
The prototype of Set iterator objects (
|
|
|
|
Set.prototype
|
The initial value of the
prototype
|
|
|
SharedArrayBuffer
|
The
SharedArrayBuffer
|
|
|
SharedArrayBuffer.prototype
|
The initial value of the
prototype
|
|
|
String
|
The
String
|
|
|
The prototype of String iterator objects (
|
|
|
|
String.prototype
|
The initial value of the
prototype
|
|
|
Symbol
|
The
Symbol
|
|
|
Symbol.prototype
|
The initial value of the
prototype
|
| %SyntaxError% |
SyntaxError
|
The
SyntaxError
|
| %SyntaxErrorPrototype% |
SyntaxError.prototype
|
The initial value of the
prototype
|
|
|
A
|
|
|
|
The super class of all typed Array constructors (
|
|
|
|
The initial value of the
prototype
|
|
| %TypeError% |
TypeError
|
The
TypeError
|
| %TypeErrorPrototype% |
TypeError.prototype
|
The initial value of the
prototype
|
| %Uint8Array% |
Uint8Array
|
The
Uint8Array
|
| %Uint8ArrayPrototype% |
Uint8Array.prototype
|
The initial value of the
prototype
|
| %Uint8ClampedArray% |
Uint8ClampedArray
|
The
Uint8ClampedArray
|
| %Uint8ClampedArrayPrototype% |
Uint8ClampedArray.prototype
|
The initial value of the
prototype
|
| %Uint16Array% |
Uint16Array
|
The
Uint16Array
|
| %Uint16ArrayPrototype% |
Uint16Array.prototype
|
The initial value of the
prototype
|
| %Uint32Array% |
Uint32Array
|
The
Uint32Array
|
| %Uint32ArrayPrototype% |
Uint32Array.prototype
|
The initial value of the
prototype
|
| %URIError% |
URIError
|
The
URIError
|
| %URIErrorPrototype% |
URIError.prototype
|
The initial value of the
prototype
|
|
|
WeakMap
|
The
WeakMap
|
|
|
WeakMap.prototype
|
The initial value of the
prototype
|
|
|
WeakSet
|
The
WeakSet
|
|
|
WeakSet.prototype
|
The initial value of the
prototype
|
A specification type corresponds to meta-values that are used
within algorithms to describe the semantics of ECMAScript language
constructs and ECMAScript language types. The specification types
include
The
List
type is used to explain the evaluation of argument lists (see
new
expressions, in function calls, and in other algorithms where a simple
ordered list of values is needed. Values of the List type are simply
ordered sequences of list elements containing the individual values.
These sequences may be of any length. The elements of a list may be
randomly accessed using 0-origin indices. For notational convenience an
array-like syntax can be used to access List elements. For example,
arguments
[2] is shorthand for saying the 3
rd
element of the List
arguments
.
For notational convenience within this specification, a literal syntax can be used to express a new List value. For example, « 1, 2 » defines a List value that has two elements each of which is initialized to a specific value. A new empty List can be expressed as « ».
The Record type is used to describe data aggregations within the algorithms of this specification. A Record type value consists of one or more named fields. The value of each field is either an ECMAScript value or an abstract value represented by a name associated with the Record type. Field names are always enclosed in double brackets, for example [[Value]].
For notational convenience within this specification, an object
literal-like syntax can be used to express a Record value. For example,
{ [[Field1]]: 42, [[Field2]]:
In specification text and algorithms, dot notation may be used to refer to a specific field of a Record value. For example, if R is the record shown in the previous paragraph then R.[[Field2]] is shorthand for “the field of R named [[Field2]]”.
Schema for commonly used Record field combinations may be
named, and that name may be used as a prefix to a literal Record value
to identify the specific kind of aggregations that is being described.
For example: PropertyDescriptor { [[Value]]: 42, [[Writable]]:
The
Set
type is used to explain a collection of unordered elements for use in the
The Relation type is used to explain constraints on Sets. Values of the Relation type are Sets of ordered pairs of values from its value domain. For example, a Relation on events is a set of ordered pairs of events. For a Relation R and two values a and b in the value domain of R , a R b is shorthand for saying the ordered pair ( a , b ) is a member of R . A Relation is least with respect to some conditions when it is the smallest Relation that satisfies those conditions.
A strict partial order is a Relation value R that satisfies the following.
For all a , b , and c in R 's domain:
The two properties above are called, in order, irreflexivity and transitivity.
A strict total order is a Relation value R that satisfies the following.
For all a , b , and c in R 's domain:
The three properties above are called, in order, totality, irreflexivity, and transitivity.
The Completion type is a
break
,
continue
,
return
and
throw
) that perform nonlocal transfers of control.
Values of the Completion type are
| Field Name | Value | Meaning |
|---|---|---|
| [[Type]] |
One of
|
The type of completion that occurred. |
| [[Value]] |
any
|
The value that was produced. |
| [[Target]] |
any ECMAScript string or
|
The target label for directed control transfers. |
The term “
abrupt completion
” refers to any completion with a [[Type]] value other than
Algorithm steps that say
mean the same thing as:
where all variables in the above steps, with the exception of completion , are ephemeral and visible only in the steps pertaining to Await.
Await can be combined with the
?
and
!
prefixes, so that for example
means the same thing as:
An
When an
The
"length"
property of an
An
When an
The
"length"
property of an
The abstract operation NormalCompletion with a single argument , such as:
Is a shorthand that is defined as follows:
The abstract operation ThrowCompletion with a single argument , such as:
Is a shorthand that is defined as follows:
The abstract operation UpdateEmpty with arguments completionRecord and value performs the following steps:
The Reference type is used to explain the behaviour of such operators as
delete
,
typeof
, the assignment operators, the
super
keyword and other language features. For example, the left-hand operand of an assignment is expected to produce a reference.
A
Reference
is a resolved name or property binding.
A Reference consists of three components, the base value component, the
referenced name component, and the Boolean-valued strict reference
flag. The base value component is either
A
Super Reference
is a Reference that is used to represent a name binding that was expressed using the super keyword. A
The following
The object that may be created in step 5.a.ii is not accessible outside of the above abstract operation and the ordinary object [[Get]] internal method. An implementation might choose to avoid the actual creation of the object.
The object that may be created in step 6.a.ii is not accessible outside of the above algorithm and the ordinary object [[Set]] internal method. An implementation might choose to avoid the actual creation of that object.
The
Property Descriptor
type is used to explain the
manipulation and reification of Object property attributes. Values of
the Property Descriptor type are Records. Each field's name is an
attribute name and its value is a corresponding attribute value as
specified in
Property Descriptor values may be further classified as data
Property Descriptors and accessor Property Descriptors based upon the
existence or use of certain fields. A data Property Descriptor is one
that includes any fields named either [[Value]] or [[Writable]]. An
accessor Property Descriptor is one that includes any fields named
either [[Get]] or [[Set]]. Any Property Descriptor may have fields named
[[Enumerable]] and [[Configurable]]. A Property Descriptor value may
not be both a data Property Descriptor and an accessor Property
Descriptor; however, it may be neither. A generic Property Descriptor is
a Property Descriptor value that is neither a data Property Descriptor
nor an accessor Property Descriptor. A fully populated Property
Descriptor is one that is either an accessor Property Descriptor or a
data Property Descriptor and that has all of the fields that correspond
to the property attributes defined in either
The following
When the abstract operation IsAccessorDescriptor is called with
When the abstract operation IsDataDescriptor is called with
When the abstract operation IsGenericDescriptor is called with
When the abstract operation FromPropertyDescriptor is called with
"value"
,
Desc
.[[Value]]).
"writable"
,
Desc
.[[Writable]]).
"get"
,
Desc
.[[Get]]).
"set"
,
Desc
.[[Set]]).
"enumerable"
,
Desc
.[[Enumerable]]).
"configurable"
,
Desc
.[[Configurable]]).
When the abstract operation ToPropertyDescriptor is called with object Obj , the following steps are taken:
"enumerable"
).
"configurable"
).
"value"
).
"value"
).
"writable"
).
"get"
).
"get"
).
"set"
).
"set"
).
When the abstract operation CompletePropertyDescriptor is called with
The
The Data Block specification type is used to describe a distinct and mutable sequence of byte-sized (8 bit) numeric values. A Data Block value is created with a fixed number of bytes that each have the initial value 0.
For notational convenience within this specification, an array-like syntax can be used to access the individual bytes of a Data Block value. This notation presents a Data Block value as a 0-origined integer-indexed sequence of bytes. For example, if db is a 5 byte Data Block value then db [2] can be used to access its 3 rd byte.
A data block that resides in memory that can be referenced from multiple agents concurrently is designated a Shared Data Block . A Shared Data Block has an identity (for the purposes of equality testing Shared Data Block values) that is address-free : it is tied not to the virtual addresses the block is mapped to in any process, but to the set of locations in memory that the block represents. Two data blocks are equal only if the sets of the locations they contain are equal; otherwise, they are not equal and the intersection of the sets of locations they contain is empty. Finally, Shared Data Blocks can be distinguished from Data Blocks.
The semantics of Shared Data Blocks is defined using Shared Data Block events by the
Shared Data Block events are modeled by Records, defined in the
The following
When the abstract operation CreateByteDataBlock is called with integer argument size , the following steps are taken:
When the abstract operation CreateSharedByteDataBlock is called with integer argument size , the following steps are taken:
"Init"
, [[NoTear]]:
When the abstract operation CopyDataBlockBytes is called, the following steps are taken:
"Unordered"
, [[NoTear]]:
"Unordered"
, [[NoTear]]:
These operations are not a part of the ECMAScript language; they
are defined here to solely to aid the specification of the semantics of
the ECMAScript language. Other, more specialized
The ECMAScript language implicitly performs automatic type
conversion as needed. To clarify the semantics of certain constructs it
is useful to define a set of conversion
The abstract operation ToPrimitive takes an input argument and an optional argument PreferredType . The abstract operation ToPrimitive converts its input argument to a non-Object type. If an object is capable of converting to more than one primitive type, it may use the optional hint PreferredType to favour that type. Conversion occurs according to the following algorithm:
"default"
.
"string"
.
"number"
.
"default"
, set
hint
to
"number"
.
When ToPrimitive is called with no hint, then it generally
behaves as if the hint were Number. However, objects may over-ride this
behaviour by defining a @@toPrimitive method. Of the objects defined in
this specification only Date objects (see
When the abstract operation OrdinaryToPrimitive is called with arguments O and hint , the following steps are taken:
"string"
or
"number"
.
"string"
, then
"toString"
,
"valueOf"
».
"valueOf"
,
"toString"
».
The abstract operation ToBoolean converts
argument
to a value of type Boolean according to
| Argument Type | Result |
|---|---|
| Undefined |
Return
|
| Null |
Return
|
| Boolean | Return argument . |
| Number |
If
argument
is
|
| String |
If
argument
is the empty String (its length is zero), return
|
| Symbol |
Return
|
| Object |
Return
|
The abstract operation ToNumber converts
argument
to a value of type Number according to
| Argument Type | Result |
|---|---|
| Undefined |
Return
|
| Null |
Return
|
| Boolean |
If
argument
is
|
| Number | Return argument (no conversion). |
| String | See grammar and conversion algorithm below. |
| Symbol |
Throw a
|
| Object |
Apply the following steps:
|
The terminal symbols of this grammar are all composed of
characters in the Unicode Basic Multilingual Plane (BMP). Therefore, the
result of
All grammar symbols not explicitly defined above have the definitions used in the Lexical Grammar for numeric literals (
Some differences should be noted between the syntax of a
0
digits.
+
or
-
to indicate its sign.
Infinity
and
-Infinity
are recognized as a
The conversion of a String to a Number value is similar
overall to the determination of the Number value for a numeric literal
(see
Once the exact MV for a String numeric literal has been
determined, it is then rounded to a value of the Number type. If the MV
is 0, then the rounded value is
"-"
, in which case the rounded value is
0
; or
The abstract operation ToInteger converts argument to an integral numeric value. This abstract operation functions as follows:
The abstract operation ToInt32 converts
argument
to one of 2
32
integer values in the range
Given the above definition of ToInt32:
The abstract operation ToUint32 converts
argument
to one of 2
32
integer values in the range 0 through
Given the above definition of ToUint32:
The abstract operation ToInt16 converts argument to one of 2 16 integer values in the range -32768 through 32767, inclusive. This abstract operation functions as follows:
The abstract operation ToUint16 converts
argument
to one of 2
16
integer values in the range 0 through
Given the above definition of ToUint16:
The abstract operation ToInt8 converts argument to one of 2 8 integer values in the range -128 through 127, inclusive. This abstract operation functions as follows:
The abstract operation ToUint8 converts argument to one of 2 8 integer values in the range 0 through 255, inclusive. This abstract operation functions as follows:
The abstract operation ToUint8Clamp converts argument to one of 2 8 integer values in the range 0 through 255, inclusive. This abstract operation functions as follows:
Unlike the other ECMAScript integer conversion abstract
operation, ToUint8Clamp rounds rather than truncates non-integer values
and does not convert
Math.round
which does “round half up” tie-breaking.
The abstract operation ToString converts
argument
to a value of type String according to
| Argument Type | Result |
|---|---|
| Undefined |
Return
"undefined"
.
|
| Null |
Return
"null"
.
|
| Boolean |
If
argument
is
If
argument
is
|
| Number |
Return
|
| String | Return argument . |
| Symbol |
Throw a
|
| Object |
Apply the following steps:
|
The abstract operation NumberToString converts a Number m to String format as follows:
"NaN"
.
"0"
.
"-"
and !
"Infinity"
.
The following observations may be useful as guidelines for implementations, but are not part of the normative requirements of this Standard:
For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step 5 be used as a guideline:
Implementers of ECMAScript may find useful the paper and code written by David M. Gay for binary-to-decimal conversion of floating-point numbers:
Gay, David M. Correctly Rounded Binary-Decimal and
Decimal-Binary Conversions. Numerical Analysis, Manuscript 90-10.
AT&T Bell Laboratories (Murray Hill, New Jersey). November 30, 1990.
Available as
http://ampl.com/REFS/abstracts.html#rounding
. Associated code available as
http://netlib.sandia.gov/fp/dtoa.c
and as
http://netlib.sandia.gov/fp/g_fmt.c
and may also be found at the various
netlib
mirror sites.
The abstract operation ToObject converts
argument
to a value of type Object according to
| Argument Type | Result |
|---|---|
| Undefined |
Throw a
|
| Null |
Throw a
|
| Boolean |
Return a new Boolean object whose [[BooleanData]] internal slot is set to
argument
. See
|
| Number |
Return a new Number object whose [[NumberData]] internal slot is set to
argument
. See
|
| String |
Return a new String object whose [[StringData]] internal slot is set to
argument
. See
|
| Symbol |
Return a new Symbol object whose [[SymbolData]] internal slot is set to
argument
. See
|
| Object | Return argument . |
The abstract operation ToPropertyKey converts argument to a value that can be used as a property key by performing the following steps:
The abstract operation ToLength converts argument to an integer suitable for use as the length of an array-like object. It performs the following steps:
The abstract operation CanonicalNumericIndexString returns
argument
converted to a numeric value if it is a String representation of a Number that would be produced by
"-0"
. Otherwise, it returns
A
canonical numeric string
is any String value for which the CanonicalNumericIndexString abstract operation does not return
The abstract operation ToIndex returns
value
argument converted to a numeric value if it is a valid
The abstract operation RequireObjectCoercible throws an error if
argument
is a value that cannot be converted to an Object using
| Argument Type | Result |
|---|---|
| Undefined |
Throw a
|
| Null |
Throw a
|
| Boolean | Return argument . |
| Number | Return argument . |
| String | Return argument . |
| Symbol | Return argument . |
| Object | Return argument . |
The abstract operation IsArray takes one argument argument , and performs the following steps:
The abstract operation IsCallable determines if
argument
, which must be an
The abstract operation IsConstructor determines if
argument
, which must be an
The abstract operation IsExtensible is used to determine whether additional properties can be added to the object that is O . A Boolean value is returned. This abstract operation performs the following steps:
The abstract operation IsInteger determines if argument is a finite integer numeric value.
The abstract operation IsPropertyKey determines if
argument
, which must be an
The abstract operation IsRegExp with argument argument performs the following steps:
The abstract operation IsStringPrefix determines if String p is a prefix of String q .
The internal comparison abstract operation SameValue(
x
,
y
), where
x
and
y
are ECMAScript language values, produces
This algorithm differs from the
The internal comparison abstract operation SameValueZero(
x
,
y
), where
x
and
y
are ECMAScript language values, produces
SameValueZero differs from
The internal comparison abstract operation SameValueNonNumber(
x
,
y
), where neither
x
nor
y
are Number values, produces
The comparison
x
<
y
, where
x
and
y
are values, produces
Step 3 differs from step 7 in the algorithm for the addition operator
+
(
The comparison of Strings uses a simple lexicographic ordering on sequences of code unit values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore String values that are canonically equal according to the Unicode standard could test as unequal. In effect this algorithm assumes that both Strings are already in normalized form. Also, note that for strings containing supplementary characters, lexicographic ordering on sequences of UTF-16 code unit values differs from that on sequences of code point values.
The comparison
x
==
y
, where
x
and
y
are values, produces
The comparison
x
===
y
, where
x
and
y
are values, produces
This algorithm differs from the
The abstract operation Get is used to retrieve the value of a specific property of an object. The operation is called with arguments O and P where O is the object and P is the property key. This abstract operation performs the following steps:
The abstract operation GetV is used to retrieve the value of a specific property of an
The abstract operation Set is used to set the value of a specific property of an object. The operation is called with arguments O , P , V , and Throw where O is the object, P is the property key, V is the new value for the property and Throw is a Boolean flag. This abstract operation performs the following steps:
The abstract operation CreateDataProperty is used to create a new own property of an object. The operation is called with arguments O , P , and V where O is the object, P is the property key, and V is the value for the property. This abstract operation performs the following steps:
This abstract operation creates a property whose attributes
are set to the same defaults used for properties created by the
ECMAScript language assignment operator. Normally, the property will not
already exist. If it does exist and is not configurable or if
O
is not extensible, [[DefineOwnProperty]] will return
The abstract operation CreateMethodProperty is used to create a new own property of an object. The operation is called with arguments O , P , and V where O is the object, P is the property key, and V is the value for the property. This abstract operation performs the following steps:
This abstract operation creates a property whose attributes
are set to the same defaults used for built-in methods and methods
defined using class declaration syntax. Normally, the property will not
already exist. If it does exist and is not configurable or if
O
is not extensible, [[DefineOwnProperty]] will return
The abstract operation CreateDataPropertyOrThrow is used to create a new own property of an object. It throws a
This abstract operation creates a property whose attributes
are set to the same defaults used for properties created by the
ECMAScript language assignment operator. Normally, the property will not
already exist. If it does exist and is not configurable or if
O
is not extensible, [[DefineOwnProperty]] will return
The abstract operation DefinePropertyOrThrow is used to call
the [[DefineOwnProperty]] internal method of an object in a manner that
will throw a
The abstract operation DeletePropertyOrThrow is used to remove a specific own property of an object. It throws an exception if the property is not configurable. The operation is called with arguments O and P where O is the object and P is the property key. This abstract operation performs the following steps:
The abstract operation GetMethod is used to get the value of a specific property of an
The abstract operation HasProperty is used to determine whether an object has a property with the specified property key. The property may be either an own or inherited. A Boolean value is returned. The operation is called with arguments O and P where O is the object and P is the property key. This abstract operation performs the following steps:
The abstract operation HasOwnProperty is used to determine whether an object has an own property with the specified property key. A Boolean value is returned. The operation is called with arguments O and P where O is the object and P is the property key. This abstract operation performs the following steps:
The abstract operation Call is used to call the [[Call]] internal method of a
The abstract operation Construct is used to call the [[Construct]] internal method of a
If
newTarget
is not present, this operation is equivalent to:
new F(...argumentsList)
The abstract operation SetIntegrityLevel is used to fix the set of own properties of an object. This abstract operation performs the following steps:
"sealed"
or
"frozen"
.
"sealed"
, then
"frozen"
,
The abstract operation TestIntegrityLevel is used to determine if the set of own properties of an object are fixed. This abstract operation performs the following steps:
"sealed"
or
"frozen"
.
"frozen"
and
The abstract operation CreateArrayFromList is used to create an Array object whose elements are provided by a
The abstract operation CreateListFromArrayLike is used to create a
"length"
)).
The abstract operation Invoke is used to call a method property of an
The abstract operation OrdinaryHasInstance implements the default algorithm for determining if an object
O
inherits from the instance object inheritance path provided by
"prototype"
).
The abstract operation SpeciesConstructor is used to retrieve the
"constructor"
).
When the abstract operation EnumerableOwnPropertyNames is called with Object O and String kind the following steps are taken:
The abstract operation GetFunctionRealm with argument obj performs the following steps:
Step 5 will only be reached if
obj
is a non-standard function
When the abstract operation CopyDataProperties is called with arguments target , source , and excludedItems , the following steps are taken:
The target passed in here is always a newly created object which is not directly accessible in case of an error being thrown.
See Common Iteration Interfaces (
The abstract operation GetIterator with argument obj and optional arguments hint and method performs the following steps:
"next"
).
The abstract operation IteratorNext with argument iteratorRecord and optional argument value performs the following steps:
The abstract operation IteratorComplete with argument iterResult performs the following steps:
The abstract operation IteratorValue with argument iterResult performs the following steps:
The abstract operation IteratorStep with argument
iteratorRecord
requests the next value from
iteratorRecord
.[[Iterator]] by calling
iteratorRecord
.[[NextMethod]] and returns either
The abstract operation IteratorClose with arguments iteratorRecord and completion is used to notify an iterator that it should perform any actions it would normally perform when it has reached its completed state:
"return"
).
The abstract operation AsyncIteratorClose with arguments iteratorRecord and completion is used to notify an async iterator that it should perform any actions it would normally perform when it has reached its completed state:
"return"
).
The abstract operation CreateIterResultObject with arguments value and done creates an object that supports the IteratorResult interface by performing the following steps:
"value"
,
value
).
"done"
,
done
).
The abstract operation CreateListIteratorRecord with argument
list
creates an Iterator (
next
(
The list iterator object is never directly accessible to ECMAScript code.
The ListIterator
next
method is a standard built-in
A
Lexical Environment
is a specification type used to define the association of
An
The outer environment reference is used to model the logical
nesting of Lexical Environment values. The outer reference of a (inner)
Lexical Environment is a reference to the Lexical Environment that
logically surrounds the inner Lexical Environment. An outer Lexical
Environment may, of course, have its own outer Lexical Environment. A
Lexical Environment may serve as the outer environment for multiple
inner Lexical Environments. For example, if a
A
global environment
is a Lexical Environment which does not have an outer environment. The
A
module environment
is a Lexical Environment that contains the bindings for the top level declarations of a
A
function environment
is a Lexical Environment that corresponds to the invocation of an ECMAScript
this
binding. A
super
method invocations.
Lexical Environments and
There are two primary kinds of
Environment Record
values used in this specification:
declarative Environment Records
and
object Environment Records
. Declarative Environment Records are used to define the effect of ECMAScript language syntactic elements such as
For specification purposes Environment Record values are values of the
| Method | Purpose |
|---|---|
| HasBinding(N) |
Determine if an
|
| CreateMutableBinding(N, D) |
Create a new but uninitialized mutable binding in an
|
| CreateImmutableBinding(N, S) |
Create a new but uninitialized immutable binding in an
|
| InitializeBinding(N, V) |
Set the value of an already existing but uninitialized binding in an
|
| SetMutableBinding(N, V, S) |
Set the value of an already existing mutable binding in an
|
| GetBindingValue(N, S) |
Returns the value of an already existing binding from an
|
| DeleteBinding(N) |
Delete a binding from an
|
| HasThisBinding() |
Determine if an
this
binding. Return
|
| HasSuperBinding() |
Determine if an
super
method binding. Return
|
| WithBaseObject() |
If this
with
statement, return the with object. Otherwise, return
|
Each declarative
The behaviour of the concrete specification methods for declarative Environment Records is defined by the following algorithms.
The concrete
The concrete
The concrete
The concrete
The concrete
An example of ECMAScript code that results in a missing binding at step 2 is:
function f(){eval("var x; x = (delete x, 0);")}
The concrete
The concrete
Regular declarative Environment Records do not provide a
this
binding.
Regular declarative Environment Records do not provide a
super
binding.
Declarative Environment Records always return
Each object
Object Environment Records created for
with
statements (
The behaviour of the concrete specification methods for object Environment Records is defined by the following algorithms.
The concrete
The concrete
Normally
envRec
will not have a binding for
N
but if it does, the semantics of
The concrete
The concrete
In this specification, all uses of CreateMutableBinding
for object Environment Records are immediately followed by a call to
InitializeBinding for the same name. Hence, implementations do not need
to explicitly track the initialization state of individual object
The concrete
The concrete
The concrete
Regular object Environment Records do not provide a
this
binding.
Regular object Environment Records do not provide a
super
binding.
Object Environment Records return
A
function Environment Record
is a declarative
this
binding. If a function is not an
super
, its function Environment Record also contains the state that is used to perform
super
method invocations from within the function.
Function Environment Records have the additional state fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[ThisValue]] | Any |
This is the
|
| [[ThisBindingStatus]] |
"lexical"
|
"initialized"
|
"uninitialized"
|
If the value is
"lexical"
, this is an
|
| [[FunctionObject]] | Object |
The
|
| [[HomeObject]] |
Object |
|
If the associated function has
super
property accesses and is not an
|
| [[NewTarget]] |
Object |
|
If this
|
Function Environment Records support all of the declarative
| Method | Purpose |
|---|---|
| BindThisValue(V) | Set the [[ThisValue]] and record that it has been initialized. |
| GetThisBinding() |
Return the value of this
this
binding. Throws a
this
binding has not been initialized.
|
| GetSuperBase() |
Return the object that is the base for
super
property accesses bound in this
super
property accesses will produce runtime errors.
|
The behaviour of the additional concrete specification methods for function Environment Records is defined by the following algorithms:
"lexical"
.
"initialized"
, throw a
"initialized"
.
"lexical"
, return
"lexical"
, return
"lexical"
.
"uninitialized"
, throw a
A global
A global
Properties may be created directly on a
Global Environment Records have the additional fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[ObjectRecord]] |
Object
|
Binding object is the
|
| [[GlobalThisValue]] | Object |
The value returned by
this
in global scope. Hosts may provide any ECMAScript Object value.
|
| [[DeclarativeRecord]] |
Declarative
|
Contains bindings for all declarations in global code for the associated
|
| [[VarNames]] |
|
The string names bound by
|
| Method | Purpose |
|---|---|
| GetThisBinding() |
Return the value of this
this
binding.
|
| HasVarDeclaration (N) |
Determines if the argument identifier has a binding in this
|
| HasLexicalDeclaration (N) |
Determines if the argument identifier has a binding in this
|
| HasRestrictedGlobalProperty (N) |
Determines if the argument is the name of a
|
| CanDeclareGlobalVar (N) | Determines if a corresponding CreateGlobalVarBinding call would succeed if called for the same argument N . |
| CanDeclareGlobalFunction (N) | Determines if a corresponding CreateGlobalFunctionBinding call would succeed if called for the same argument N . |
| CreateGlobalVarBinding(N, D) |
Used to create and initialize to
var
binding in the [[ObjectRecord]] component of a global
var
. The String value
N
is the bound name. If
D
is
|
| CreateGlobalFunctionBinding(N, V, D) |
Create and initialize a global
function
binding in the [[ObjectRecord]] component of a global
function
. The String value
N
is the bound name.
V
is the initialization value. If the Boolean argument
D
is
|
The behaviour of the concrete specification methods for global Environment Records is defined by the following algorithms.
The concrete
The concrete
The concrete
The concrete
The concrete
The concrete
The concrete
Global Environment Records always return
The concrete
The concrete
The concrete
Properties may exist upon a
undefined
is an example of such a property.
The concrete
The concrete
The concrete
The concrete
Global function declarations are always represented as own properties of the
A module
Module Environment Records support all of the declarative
| Method | Purpose |
|---|---|
| CreateImportBinding(N, M, N2) |
Create an immutable indirect binding in a module
|
| GetThisBinding() |
Return the value of this
this
binding.
|
The behaviour of the additional concrete specification methods for module Environment Records are defined by the following algorithms:
The concrete
S
will always be
The concrete
Module Environment Records are only used within strict code and an
Module Environment Records provide a
this
binding.
The concrete
The following
The abstract operation GetIdentifierReference is called with a
When the abstract operation NewDeclarativeEnvironment is called with a
When the abstract operation NewObjectEnvironment is called with an Object
O
and a
When the abstract operation NewFunctionEnvironment is called with arguments F and newTarget the following steps are performed:
"lexical"
.
"uninitialized"
.
When the abstract operation NewGlobalEnvironment is called with arguments G and thisValue , the following steps are performed:
When the abstract operation NewModuleEnvironment is called with a
Before it is evaluated, all ECMAScript code must be associated with a
realm
. Conceptually, a
A
| Field Name | Value | Meaning |
|---|---|---|
| [[Intrinsics]] |
|
The intrinsic values used by code associated with this
|
| [[GlobalObject]] | Object |
The
|
| [[GlobalEnv]] |
|
The
|
| [[TemplateMap]] |
A
|
Template objects are canonicalized separately for each
Once a
|
| [[HostDefined]] |
Any, default value is
|
Field reserved for use by host environments that need to associate additional information with a
|
The abstract operation CreateRealm with no arguments performs the following steps:
The abstract operation CreateIntrinsics with argument realmRec performs the following steps:
The abstract operation SetRealmGlobalObject with arguments realmRec , globalObj , and thisValue performs the following steps:
The abstract operation SetDefaultGlobalBindings with argument realmRec performs the following steps:
An
execution context
is a specification device that
is used to track the runtime evaluation of code by an ECMAScript
implementation. At any point in time, there is at most one execution
context per
The
execution context stack
is used to track execution contexts. The
An execution context contains whatever implementation specific
state is necessary to track the execution progress of its associated
code. Each execution context has at least the state components listed in
| Component | Purpose |
|---|---|
| code evaluation state |
Any state needed to perform, suspend, and resume evaluation of the code associated with this
|
| Function |
If this
|
|
|
The
|
| ScriptOrModule |
The
|
Evaluation of code by the
The value of the
Execution contexts for ECMAScript code have the additional state components listed in
| Component | Purpose |
|---|---|
| LexicalEnvironment |
Identifies the
|
| VariableEnvironment |
Identifies the
|
The LexicalEnvironment and VariableEnvironment components of an execution context are always Lexical Environments.
Execution contexts representing the evaluation of generator objects have the additional state components listed in
| Component | Purpose |
|---|---|
| Generator |
The GeneratorObject that this
|
In most situations only the
An execution context is purely a specification mechanism and need not correspond to any particular artefact of an ECMAScript implementation. It is impossible for ECMAScript code to directly access or observe an execution context.
The GetActiveScriptOrModule abstract operation is used to determine the running script or module, based on the
The ResolveBinding abstract operation is used to determine the binding of
name
passed as a String value. The optional argument
env
can be used to explicitly provide the
The result of ResolveBinding is always a
The abstract operation GetThisEnvironment finds the
this
. GetThisEnvironment performs the following steps:
The loop in step 2 will always terminate because the list of environments always ends with the
this
binding.
The abstract operation ResolveThisBinding determines the binding of the keyword
this
using the LexicalEnvironment of the
The abstract operation GetNewTarget determines the NewTarget value using the LexicalEnvironment of the
The abstract operation GetGlobalObject returns the
A Job is an abstract operation that initiates an ECMAScript computation when no other ECMAScript computation is currently in progress. A Job abstract operation may be defined to accept an arbitrary set of job parameters.
Execution of a Job can be initiated only when there is no
| Field Name | Value | Meaning |
|---|---|---|
| [[Job]] | The name of a Job abstract operation | This is the abstract operation that is performed when execution of this PendingJob is initiated. |
| [[Arguments]] |
A
|
The
|
| [[Realm]] |
A
|
The
|
| [[ScriptOrModule]] |
A
|
The script or module for the initial
|
| [[HostDefined]] |
Any, default value is
|
Field reserved for use by host environments that need to associate additional information with a pending Job. |
A Job Queue is a FIFO queue of PendingJob records. Each Job Queue
has a name and the full set of available Job Queues are defined by an
ECMAScript implementation. Every ECMAScript implementation has at least
the Job Queues defined in
Each
A request for the future execution of a Job is made by
enqueueing, on a Job Queue, a PendingJob record that includes a Job
abstract operation name and any necessary argument values. When there is
no
The PendingJob records from a single Job Queue are always
initiated in FIFO order. This specification does not define the order in
which multiple Job Queues are serviced. An ECMAScript implementation
may interweave the FIFO evaluation of the PendingJob records of a Job
Queue with the evaluation of the PendingJob records of one or more other
Job Queues. An implementation must define what occurs when there are no
Typically an ECMAScript implementation will have its Job Queues
pre-initialized with at least one PendingJob and one of those Jobs will
be the first to be executed. An implementation might choose to free all
resources and terminate if the current Job completes and all Job Queues
are empty. Alternatively, it might choose to wait for a some
implementation specific
The following
The EnqueueJob abstract operation requires three arguments: queueName , job , and arguments . It performs the following steps:
The abstract operation InitializeHostDefinedRealm performs the following steps:
this
binding in
realm
's global scope return an object other than the
this
binding should be the
The abstract operation RunJobs performs the following steps:
"ScriptJobs"
,
"ScriptJobs"
,
An
agent
comprises a set of ECMAScript execution contexts, an
An
Some web browsers share a single
While an
| Field Name | Value | Meaning |
|---|---|---|
| [[LittleEndian]] | Boolean |
The default value computed for the
isLittleEndian
parameter when it is needed by the algorithms
|
| [[CanBlock]] | Boolean |
Determines whether the
|
| [[Signifier]] | Any globally-unique value |
Uniquely identifies the
|
| [[IsLockFree1]] | Boolean |
|
| [[IsLockFree2]] | Boolean |
|
| [[CandidateExecution]] |
A
|
See the
|
Once the values of [[Signifier]], [[IsLockFree1]], and [[IsLockFree2]] have been observed by any
The values of [[IsLockFree1]] and [[IsLockFree2]] are not necessarily determined by the hardware, but may also reflect implementation choices that can vary over time and between ECMAScript implementations.
There is no [[IsLockFree4]] property: 4-byte atomic operations are always lock-free.
In practice, if an atomic operation is implemented with any type of lock the operation is not lock-free. Lock-free does not imply wait-free: there is no upper bound on how many machine steps may be required to complete a lock-free atomic operation.
That an atomic access of size
n
is lock-free does not imply anything about the (perceived) atomicity of non-atomic accesses of size
n
, specifically, non-atomic accesses may still be performed as a sequence of several separate memory accesses. See
An
The abstract operation AgentSignifier takes no arguments. It performs the following steps:
The abstract operation AgentCanSuspend takes no arguments. It performs the following steps:
In some environments it may not be reasonable for a given
An agent cluster is a maximal set of agents that can communicate by operating on shared memory.
Programs within different agents may share memory by unspecified means. At a minimum, the backing memory for SharedArrayBuffer objects can be shared among the agents in the cluster.
There may be agents that can communicate by message passing that cannot share memory; they are never in the same agent cluster.
Every
All agents within a cluster must have the same value for the [[LittleEndian]] property in their respective
If different agents within an agent cluster have different values of [[LittleEndian]] it becomes hard to use shared memory for multi-byte data.
All agents within a cluster must have the same values for the [[IsLockFree1]] property in their respective
All agents within a cluster must have different values for the [[Signifier]] property in their respective
An embedding may deactivate (stop forward progress) or activate (resume forward progress) an
The purpose of the preceding restriction is to avoid a situation where an
The implication of the restriction is that it will not be possible to share memory between agents that don't belong to the same suspend/wake collective within the embedding.
An embedding may terminate an
Prior to any evaluation of any ECMAScript code by any
All agents in an agent cluster share the same
An agent cluster is a specification mechanism and need not correspond to any particular artefact of an ECMAScript implementation.
For an
An
Implementations must ensure that:
This, along with the liveness guarantee in the
"SeqCst"
writes eventually become observable to all agents.
All ordinary objects have an internal slot called [[Prototype]]. The value of this internal slot is either
Every ordinary object has a Boolean-valued [[Extensible]]
internal slot which is used to fulfill the extensibility-related
internal method invariants specified in
In the following algorithm descriptions, assume
O
is an ordinary object,
P
is a property key value,
V
is any
Each ordinary object internal method delegates to a similarly-named abstract operation. If such an abstract operation depends on another internal method, then the internal method is invoked on O rather than calling the similarly-named abstract operation directly. These semantics ensure that exotic objects have their overridden internal methods invoked when ordinary object internal methods are applied to them.
When the [[GetPrototypeOf]] internal method of O is called, the following steps are taken:
When the abstract operation OrdinaryGetPrototypeOf is called with Object O , the following steps are taken:
When the [[SetPrototypeOf]] internal method of O is called with argument V , the following steps are taken:
When the abstract operation OrdinarySetPrototypeOf is called with Object O and value V , the following steps are taken:
The loop in step 8 guarantees that there will be no circularities in any prototype chain that only includes objects that use the ordinary object definitions for [[GetPrototypeOf]] and [[SetPrototypeOf]].
When the [[IsExtensible]] internal method of O is called, the following steps are taken:
When the abstract operation OrdinaryIsExtensible is called with Object O , the following steps are taken:
When the [[PreventExtensions]] internal method of O is called, the following steps are taken:
When the abstract operation OrdinaryPreventExtensions is called with Object O , the following steps are taken:
When the [[GetOwnProperty]] internal method of O is called with property key P , the following steps are taken:
When the abstract operation OrdinaryGetOwnProperty is called with Object O and with property key P , the following steps are taken:
When the [[DefineOwnProperty]] internal method of
O
is called with property key
P
and
When the abstract operation OrdinaryDefineOwnProperty is called with Object
O
, property key
P
, and
When the abstract operation IsCompatiblePropertyDescriptor is called with Boolean value Extensible , and Property Descriptors Desc , and Current , the following steps are taken:
When the abstract operation ValidateAndApplyPropertyDescriptor is called with Object O , property key P , Boolean value extensible , and Property Descriptors Desc , and current , the following steps are taken:
If
When the [[HasProperty]] internal method of O is called with property key P , the following steps are taken:
When the abstract operation OrdinaryHasProperty is called with Object O and with property key P , the following steps are taken:
When the [[Get]] internal method of
O
is called with property key
P
and
When the abstract operation OrdinaryGet is called with Object
O
, property key
P
, and
When the [[Set]] internal method of
O
is called with property key
P
, value
V
, and
When the abstract operation OrdinarySet is called with Object
O
, property key
P
, value
V
, and
When the abstract operation OrdinarySetWithOwnDescriptor is called with Object
O
, property key
P
, value
V
,
When the [[Delete]] internal method of O is called with property key P , the following steps are taken:
When the abstract operation OrdinaryDelete is called with Object O and property key P , the following steps are taken:
When the [[OwnPropertyKeys]] internal method of O is called, the following steps are taken:
When the abstract operation OrdinaryOwnPropertyKeys is called with Object O , the following steps are taken:
The abstract operation ObjectCreate with argument
proto
(an object or null) is used to specify the runtime creation of new ordinary objects. The optional argument
internalSlotsList
is a
The abstract operation OrdinaryCreateFromConstructor creates an ordinary object whose [[Prototype]] value is retrieved from a
prototype
property, if it exists. Otherwise the intrinsic named by
intrinsicDefaultProto
is used for [[Prototype]]. The optional
internalSlotsList
is a
The abstract operation GetPrototypeFromConstructor determines
the [[Prototype]] value that should be used to create an object
corresponding to a specific
prototype
property, if it exists. Otherwise the intrinsic named by
intrinsicDefaultProto
is used for [[Prototype]]. This abstract operation performs the following steps:
"prototype"
).
If
constructor
does not supply a [[Prototype]] value, the default value that is used is obtained from the
ECMAScript function objects encapsulate parameterized ECMAScript
code closed over a lexical environment and support the dynamic
evaluation of that code. An ECMAScript
ECMAScript function objects have the additional internal slots listed in
| Internal Slot | Type | Description |
|---|---|---|
| [[Environment]] |
|
The
|
| [[FormalParameters]] |
|
The root parse node of the source text that defines the function's formal parameter list. |
| [[FunctionKind]] | String |
Either
"normal"
,
"classConstructor"
,
"generator"
,
"async"
, or
"async generator"
.
|
| [[ECMAScriptCode]] |
|
The root parse node of the source text that defines the function's body. |
| [[ConstructorKind]] | String |
Either
"base"
or
"derived"
.
|
| [[Realm]] |
|
The
|
| [[ScriptOrModule]] |
|
The script or module in which the function was created. |
| [[ThisMode]] | (lexical, strict, global) |
Defines how
this
references are interpreted within the formal parameters and code body of the function.
this
refers to the
|
| [[Strict]] | Boolean |
|
| [[HomeObject]] | Object |
If the function uses
super
, this is the object whose [[GetPrototypeOf]] provides the object where
super
property lookups begin.
|
| [[SourceText]] | String |
The
|
All ECMAScript function objects have the [[Call]] internal method defined here. ECMAScript functions that are also constructors in addition have the [[Construct]] internal method.
The [[Call]] internal method for an ECMAScript
"classConstructor"
, throw a
When
calleeContext
is removed from the
When the abstract operation PrepareForOrdinaryCall is called with
When the abstract operation OrdinaryCallBindThis is called with
"initialized"
.
When the abstract operation OrdinaryCallEvaluateBody is called with
The [[Construct]] internal method for an ECMAScript
"base"
, then
"%ObjectPrototype%"
).
"base"
, perform
"base"
, return
The abstract operation FunctionAllocate requires the three arguments functionPrototype , strict and functionKind . FunctionAllocate performs the following steps:
"normal"
,
"non-constructor"
,
"generator"
,
"async"
, or
"async generator"
.
"normal"
, let
needsConstruct
be
"non-constructor"
, set
functionKind
to
"normal"
.
"base"
.
The abstract operation FunctionInitialize requires the arguments: a
The abstract operation FunctionCreate requires the arguments:
kind
which is one of (Normal, Method, Arrow), a parameter list
"non-constructor"
.
"normal"
.
The abstract operation GeneratorFunctionCreate requires the arguments:
kind
which is one of (Normal, Method), a parameter list
"generator"
).
The abstract operation AsyncGeneratorFunctionCreate requires the arguments:
kind
which is one of (
"generator"
).
The abstract operation AsyncFunctionCreate requires the arguments:
kind
which is one of (
"async"
).
The abstract operation AddRestrictedFunctionProperties is called with a
"caller"
, PropertyDescriptor { [[Get]]:
thrower
, [[Set]]:
thrower
, [[Enumerable]]:
"arguments"
, PropertyDescriptor { [[Get]]:
thrower
, [[Set]]:
thrower
, [[Enumerable]]:
The
%ThrowTypeError%
intrinsic is an anonymous built-in
The value of the [[Extensible]] internal slot of a %ThrowTypeError% function is
The
"length"
property of a %ThrowTypeError% function has the attributes { [[Writable]]:
The abstract operation MakeConstructor requires a Function argument
F
and optionally, a Boolean
writablePrototype
and an object
prototype
. If
prototype
is provided it is assumed to already contain, if needed, a
"constructor"
property whose value is
F
. This operation converts
F
into a
prototype
own property.
"constructor"
, PropertyDescriptor { [[Value]]:
F
, [[Writable]]:
writablePrototype
, [[Enumerable]]:
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
writablePrototype
, [[Enumerable]]:
The abstract operation MakeClassConstructor with argument F performs the following steps:
"normal"
.
"classConstructor"
.
The abstract operation MakeMethod with arguments F and homeObject configures F as a method by performing the following steps:
The abstract operation SetFunctionName requires a Function argument
F
, a String or Symbol argument
name
and optionally a String argument
prefix
. This operation adds a
name
property to
F
by performing the following steps:
name
own property.
"["
,
description
, and
"]"
.
"name"
, PropertyDescriptor { [[Value]]:
name
, [[Writable]]:
The abstract operation SetFunctionLength requires a Function argument
F
and a Number argument
length
. This operation adds a
"length"
property to
F
by performing the following steps:
"length"
own property.
"length"
, PropertyDescriptor { [[Value]]:
length
, [[Writable]]:
When an
FunctionDeclarationInstantiation is performed as follows using arguments
func
and
argumentsList
.
func
is the
"arguments"
is an element of
parameterNames
, then
"arguments"
is an element of
functionNames
or if
"arguments"
is an element of
lexicalNames
, then
"arguments"
,
"arguments"
,
"arguments"
,
ao
).
"arguments"
appended.
Parameter
The built-in function objects defined in this specification may be implemented as either ECMAScript function objects (
If a built-in
Unless otherwise specified every built-in
The behaviour specified for each built-in function via algorithm
steps or other means is the specification of the function body behaviour
for both [[Call]] and [[Construct]] invocations of the function.
However, [[Construct]] invocation is not supported by all built-in
functions. For each built-in function, when invoked with [[Call]], the
[[Call]]
thisArgument
provides the
"classConstructor"
.
Built-in function objects that are not identified as constructors
do not implement the [[Construct]] internal method unless otherwise
specified in the description of a particular function. When a built-in
new
expression the
argumentsList
parameter of the invoked [[Construct]] internal method provides the values for the built-in
Built-in functions that are not constructors do not have a
prototype
property unless otherwise specified in the description of a particular function.
If a built-in
The [[Call]] internal method for a built-in
When
calleeContext
is removed from the
The [[Construct]] internal method for built-in
The abstract operation CreateBuiltinFunction takes arguments
steps
,
internalSlotsList
,
realm
, and
prototype
. The argument
internalSlotsList
is a
Each built-in function defined in this specification is created by calling the CreateBuiltinFunction abstract operation.
This specification defines several kinds of built-in exotic objects. These objects generally behave similar to ordinary objects except for a few specific situations. The following exotic objects use the ordinary object internal methods except where it is explicitly specified otherwise below:
A
bound function
is an
Bound function objects do not have the internal slots of ECMAScript function objects defined in
| Internal Slot | Type | Description |
|---|---|---|
| [[BoundTargetFunction]] | Callable Object |
The wrapped
|
| [[BoundThis]] | Any |
The value that is always passed as the
|
| [[BoundArguments]] |
|
A list of values whose elements are used as the first arguments to any call to the wrapped function. |
Bound function objects provide all of the essential internal methods as specified in
When the [[Call]] internal method of a
When the [[Construct]] internal method of a
The abstract operation BoundFunctionCreate with arguments targetFunction , boundThis and boundArgs is used to specify the creation of new Bound Function exotic objects. It performs the following steps:
An
Array object
is an
"length"
property whose value is always a nonnegative integer less than 2
32
. The value of the
"length"
property is numerically greater than the name of every own property whose name is an
"length"
property is changed, if necessary, to be one more than the numeric value of that
"length"
property is changed, every own property whose name is an
"length"
or
A String
Array exotic objects provide an alternative definition for the
[[DefineOwnProperty]] internal method. Except for that internal method,
Array exotic objects provide all of the other essential internal methods
as specified in
When the [[DefineOwnProperty]] internal method of an Array
"length"
, then
"length"
).
"length"
,
oldLenDesc
).
The abstract operation ArrayCreate with argument length (either 0 or a positive integer) and optional argument proto is used to specify the creation of new Array exotic objects. It performs the following steps:
"length"
, PropertyDescriptor { [[Value]]:
length
, [[Writable]]:
The abstract operation ArraySpeciesCreate with arguments
originalArray
and
length
is used to specify the creation of a new Array object using a
"constructor"
).
If
originalArray
was created using the standard built-in Array
When the abstract operation ArraySetLength is called with an Array
"length"
,
Desc
).
"length"
).
"length"
,
newLenDesc
).
"length"
,
newLenDesc
).
"length"
,
newLenDesc
).
"length"
, PropertyDescriptor { [[Writable]]:
In steps 3 and 4, if
Desc
.[[Value]] is an object then its
valueOf
method is called twice. This is legacy behaviour that was specified with this effect starting with the 2
nd
Edition of this specification.
A
String object
is an
"length"
whose value is the number of code unit elements in the encapsulated String value. Both the code unit data properties and the
"length"
property are non-writable and non-configurable.
String exotic objects have the same internal slots as ordinary objects. They also have a [[StringData]] internal slot.
String exotic objects provide alternative definitions for the following internal methods. All of the other String
When the [[GetOwnProperty]] internal method of a String
When the [[DefineOwnProperty]] internal method of a String
When the [[OwnPropertyKeys]] internal method of a String
The abstract operation StringCreate with arguments value and prototype is used to specify the creation of new String exotic objects. It performs the following steps:
"length"
, PropertyDescriptor { [[Value]]:
length
, [[Writable]]:
The abstract operation StringGetOwnProperty called with arguments S and P performs the following steps:
Most ECMAScript functions make an arguments object available to
their code. Depending upon the characteristics of the function
definition, its arguments object is either an ordinary object or an
arguments
Arguments exotic objects have the same internal slots as
ordinary objects. They also have a [[ParameterMap]] internal slot.
Ordinary arguments objects also have a [[ParameterMap]] internal slot
whose value is always undefined. For ordinary argument objects the
[[ParameterMap]] internal slot is only used by
Object.prototype.toString
(
Arguments exotic objects provide alternative definitions for the following internal methods. All of the other arguments
The integer-indexed data properties of an arguments
The ParameterMap object and its property values are used as a device for specifying the arguments object correspondence to argument bindings. The ParameterMap object and the objects that are the values of its properties are not directly observable from ECMAScript code. An ECMAScript implementation does not need to actually create or use such objects to implement the specified semantics.
Ordinary arguments objects define a non-configurable
"callee"
which throws a
"callee"
property has a more specific meaning for arguments exotic objects,
which are created only for some class of non-strict functions. The
definition of this property in the ordinary variant exists to ensure
that it is not defined in any other manner by conforming ECMAScript
implementations.
ECMAScript implementations of arguments exotic objects have historically contained an
"caller"
. Prior to ECMAScript 2017, this specification included the definition of a throwing
"caller"
property on ordinary arguments objects. Since implementations do not
contain this extension any longer, ECMAScript 2017 dropped the
requirement for a throwing
"caller"
accessor.
The [[GetOwnProperty]] internal method of an arguments
The [[DefineOwnProperty]] internal method of an arguments
The [[Get]] internal method of an arguments
The [[Set]] internal method of an arguments
The [[Delete]] internal method of an arguments
The abstract operation CreateUnmappedArgumentsObject called with an argument argumentsList performs the following steps:
"length"
, PropertyDescriptor { [[Value]]:
len
, [[Writable]]:
"callee"
, PropertyDescriptor { [[Get]]:
The abstract operation CreateMappedArgumentsObject is called with object
func
,
"length"
, PropertyDescriptor { [[Value]]:
len
, [[Writable]]:
"callee"
, PropertyDescriptor { [[Value]]:
func
, [[Writable]]:
The abstract operation MakeArgGetter called with String
name
and
An ArgGetter function is an anonymous built-in function with [[Name]] and [[Env]] internal slots. When an ArgGetter function that expects no arguments is called it performs the following steps:
ArgGetter functions are never directly accessible to ECMAScript code.
The abstract operation MakeArgSetter called with String
name
and
An ArgSetter function is an anonymous built-in function with [[Name]] and [[Env]] internal slots. When an ArgSetter function is called with argument value it performs the following steps:
ArgSetter functions are never directly accessible to ECMAScript code.
An
Integer-Indexed exotic object
is an
When the [[GetOwnProperty]] internal method of an
When the [[HasProperty]] internal method of an
When the [[DefineOwnProperty]] internal method of an
When the [[Get]] internal method of an
When the [[Set]] internal method of an
When the [[OwnPropertyKeys]] internal method of an
The abstract operation IntegerIndexedObjectCreate with arguments
prototype
and
internalSlotsList
is used to specify the creation of new
The abstract operation IntegerIndexedElementGet with arguments O and index performs the following steps:
"Unordered"
).
The abstract operation IntegerIndexedElementSet with arguments O , index , and value performs the following steps:
"Unordered"
).
A
module namespace object
is an
export *
export items. Each String-valued own property key is the StringValue of
the corresponding exported binding name. These are the only
String-keyed properties of a module namespace
Module namespace objects have the internal slots defined in
| Internal Slot | Type | Description |
|---|---|---|
| [[Module]] |
|
The
|
| [[Exports]] |
|
A
Array.prototype.sort
using
|
| [[Prototype]] | Null |
This slot always contains the value
|
Module namespace exotic objects provide alternative definitions
for all of the internal methods except [[GetPrototypeOf]], which
behaves as defined in
When the [[SetPrototypeOf]] internal method of a module namespace
When the [[IsExtensible]] internal method of a module namespace
When the [[PreventExtensions]] internal method of a module namespace
When the [[GetOwnProperty]] internal method of a module namespace
When the [[DefineOwnProperty]] internal method of a module namespace
When the [[HasProperty]] internal method of a module namespace
When the [[Get]] internal method of a module namespace
ResolveExport is idempotent and side-effect free. An
implementation might choose to pre-compute or cache the ResolveExport
results for the [[Exports]] of each module namespace
When the [[Set]] internal method of a module namespace
When the [[Delete]] internal method of a module namespace
When the [[OwnPropertyKeys]] internal method of a module namespace
The abstract operation ModuleNamespaceCreate with arguments module , and exports is used to specify the creation of new module namespace exotic objects. It performs the following steps:
Array.prototype.sort
using
An
immutable prototype exotic object
is an
Immutable prototype exotic objects have the same internal slots as ordinary objects. They are exotic only in the following internal methods. All other internal methods of immutable prototype exotic objects that are not explicitly defined below are instead defined as in ordinary objects.
When the [[SetPrototypeOf]] internal method of an
When the SetImmutablePrototype abstract operation is called with arguments O and V , the following steps are taken:
A proxy object is an
| Internal Method | Handler Method |
|---|---|
| [[GetPrototypeOf]] |
getPrototypeOf
|
| [[SetPrototypeOf]] |
setPrototypeOf
|
| [[IsExtensible]] |
isExtensible
|
| [[PreventExtensions]] |
preventExtensions
|
| [[GetOwnProperty]] |
getOwnPropertyDescriptor
|
| [[DefineOwnProperty]] |
defineProperty
|
| [[HasProperty]] |
has
|
| [[Get]] |
get
|
| [[Set]] |
set
|
| [[Delete]] |
deleteProperty
|
| [[OwnPropertyKeys]] |
ownKeys
|
| [[Call]] |
apply
|
| [[Construct]] |
construct
|
When a handler method is called to provide the implementation of a proxy object internal method, the handler method is passed the proxy's target object as a parameter. A proxy's handler object does not necessarily have a method corresponding to every essential internal method. Invoking an internal method on the proxy results in the invocation of the corresponding internal method on the proxy's target object if the handler object does not have a method corresponding to the internal trap.
The [[ProxyHandler]] and [[ProxyTarget]] internal slots of a
proxy object are always initialized when the object is created and
typically may not be modified. Some proxy objects are created in a
manner that permits them to be subsequently
revoked
. When a proxy is revoked, its [[ProxyHandler]] and [[ProxyTarget]] internal slots are set to
Because proxy objects permit the implementation of internal
methods to be provided by arbitrary ECMAScript code, it is possible to
define a proxy object whose handler methods violates the invariants
defined in
In the following algorithm descriptions, assume
O
is an ECMAScript proxy object,
P
is a property key value,
V
is any
When the [[GetPrototypeOf]] internal method of a Proxy
"getPrototypeOf"
).
[[GetPrototypeOf]] for proxy objects enforces the following invariants:
When the [[SetPrototypeOf]] internal method of a Proxy
"setPrototypeOf"
).
[[SetPrototypeOf]] for proxy objects enforces the following invariants:
When the [[IsExtensible]] internal method of a Proxy
"isExtensible"
).
[[IsExtensible]] for proxy objects enforces the following invariants:
When the [[PreventExtensions]] internal method of a Proxy
"preventExtensions"
).
[[PreventExtensions]] for proxy objects enforces the following invariants:
When the [[GetOwnProperty]] internal method of a Proxy
"getOwnPropertyDescriptor"
).
[[GetOwnProperty]] for proxy objects enforces the following invariants:
When the [[DefineOwnProperty]] internal method of a Proxy
"defineProperty"
).
[[DefineOwnProperty]] for proxy objects enforces the following invariants:
When the [[HasProperty]] internal method of a Proxy
"has"
).
[[HasProperty]] for proxy objects enforces the following invariants:
When the [[Get]] internal method of a Proxy
"get"
).
[[Get]] for proxy objects enforces the following invariants:
When the [[Set]] internal method of a Proxy
"set"
).
[[Set]] for proxy objects enforces the following invariants:
When the [[Delete]] internal method of a Proxy
"deleteProperty"
).
[[Delete]] for proxy objects enforces the following invariants:
When the [[OwnPropertyKeys]] internal method of a Proxy
"ownKeys"
).
[[OwnPropertyKeys]] for proxy objects enforces the following invariants:
The [[Call]] internal method of a Proxy
"apply"
).
A Proxy
The [[Construct]] internal method of a Proxy
"construct"
).
A Proxy
[[Construct]] for proxy objects enforces the following invariants:
The abstract operation ProxyCreate with arguments target and handler is used to specify the creation of new Proxy exotic objects. It performs the following steps:
ECMAScript code is expressed using Unicode. ECMAScript source
text is a sequence of code points. All Unicode code point values from
U+0000 to U+10FFFF, including surrogate code points, may occur in source
text where permitted by the ECMAScript grammars. The actual encodings
used to store and interchange ECMAScript source text is not relevant to
this specification. Regardless of the external source text encoding, a
conforming ECMAScript implementation processes the source text as if it
was an equivalent sequence of
The components of a combining character sequence are treated as individual Unicode code points even though a user might think of the whole sequence as a single character.
In string literals, regular expression literals, template literals and identifiers, any Unicode code point may also be expressed using Unicode escape sequences that explicitly express a code point's numeric value. Within a comment, such an escape sequence is effectively ignored as part of the comment.
ECMAScript differs from the Java programming language in the
behaviour of Unicode escape sequences. In a Java program, if the Unicode
escape sequence
\u000A
, for example, occurs within a
single-line comment, it is interpreted as a line terminator (Unicode
code point U+000A is LINE FEED (LF)) and therefore the next code point
is not part of the comment. Similarly, if the Unicode escape sequence
\u000A
occurs within a string literal in a Java program, it is likewise
interpreted as a line terminator, which is not allowed within a string
literal—one must write
\n
instead of
\u000A
to
cause a LINE FEED (LF) to be part of the String value of a string
literal. In an ECMAScript program, a Unicode escape sequence occurring
within a comment is never interpreted and therefore cannot contribute to
termination of the comment. Similarly, a Unicode escape sequence
occurring within a string literal in an ECMAScript program always
contributes to the literal and is never interpreted as a line terminator
or as a code point that might terminate the string literal.
The UTF16Encoding of a numeric code point value, cp , is determined as follows:
Two code units,
lead
and
trail
, that form a UTF-16
There are four types of ECMAScript code:
eval
function. More precisely, if the parameter to the built-in
eval
function is a String, it is treated as an ECMAScript
eval
is the global code portion of that
Function code is generally provided as the bodies of Function Definitions (
Function
GeneratorFunction
AsyncFunction
An ECMAScript
eval
is a
Function
,
Generator
,
AsyncFunction
, and
AsyncGenerator
constructors is strict mode code if the last argument is a String that when processed is a
ECMAScript code that is not strict mode code is called non-strict code .
An ECMAScript implementation may support the evaluation of
function exotic objects whose evaluative behaviour is expressed in some
implementation-defined form of executable code other than via ECMAScript
code. Whether a
The source text of an ECMAScript
There are several situations where the identification of lexical
input elements is sensitive to the syntactic grammar context that is
consuming the input elements. This requires multiple goal symbols for
the lexical grammar. The
The use of multiple lexical goals ensures that there are no
lexical ambiguities that would affect automatic semicolon insertion. For
example, there are no syntactic grammar contexts where both a leading
division or division-assignment, and a leading
a = b
/hi/g.exec(c).map(d);
where the first non-whitespace, non-comment code point after a
a = b / hi / g.exec(c).map(d);
The Unicode format-control characters (i.e., the characters in category “Cf” in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT MARK) are control codes used to control the formatting of a range of text in the absence of higher-level protocols for this (such as mark-up languages).
It is useful to allow format-control characters in source text to facilitate editing and display. All format control characters may be used within comments, and within string literals, template literals, and regular expression literals.
U+200C (ZERO WIDTH NON-JOINER) and U+200D (ZERO WIDTH JOINER) are
format-control characters that are used to make necessary distinctions
when forming words or phrases in certain languages. In ECMAScript source
text these code points may also be used in an
U+FEFF (ZERO WIDTH NO-BREAK SPACE) is a format-control character
used primarily at the start of a text to mark it as Unicode and to allow
detection of the text's encoding and byte order.
The special treatment of certain format-control characters
outside of comments, string literals, and regular expression literals is
summarized in
| Code Point | Name | Abbreviation | Usage |
|---|---|---|---|
U+200C
|
ZERO WIDTH NON-JOINER |
|
|
U+200D
|
ZERO WIDTH JOINER |
|
|
U+FEFF
|
ZERO WIDTH NO-BREAK SPACE |
|
|
White space code points are used to improve source text
readability and to separate tokens (indivisible lexical units) from each
other, but are otherwise insignificant. White space code points may
occur between any two tokens and at the start or end of input. White
space code points may occur within a
The ECMAScript white space code points are listed in
| Code Point | Name | Abbreviation |
|---|---|---|
U+0009
|
CHARACTER TABULATION |
|
U+000B
|
LINE TABULATION |
|
U+000C
|
FORM FEED (FF) |
|
U+0020
|
SPACE |
|
U+00A0
|
NO-BREAK SPACE |
|
U+FEFF
|
ZERO WIDTH NO-BREAK SPACE |
|
| Other category “Zs” | Any other Unicode “Space_Separator” code point |
|
ECMAScript implementations must recognize as
Other than for the code points listed in
Like white space code points, line terminator code points are
used to improve source text readability and to separate tokens
(indivisible lexical units) from each other. However, unlike white space
code points, line terminators have some influence over the behaviour of
the syntactic grammar. In general, line terminators may occur between
any two tokens, but there are a few places where they are forbidden by
the syntactic grammar. Line terminators also affect the process of
automatic semicolon insertion (
A line terminator can occur within a
Line terminators are included in the set of white space code points that are matched by the
\s
class in regular expressions.
The ECMAScript line terminator code points are listed in
| Code Point | Unicode Name | Abbreviation |
|---|---|---|
U+000A
|
LINE FEED (LF) |
|
U+000D
|
CARRIAGE RETURN (CR) |
|
U+2028
|
LINE SEPARATOR |
|
U+2029
|
PARAGRAPH SEPARATOR |
|
Only the Unicode code points in
Comments can be either single or multi-line. Multi-line comments cannot nest.
Because a single-line comment can contain any Unicode code point except a
//
marker to the end of the line. However, the
Comments behave like white space and are discarded except that, if a
The
This standard specifies specific code point additions: U+0024 (DOLLAR SIGN) and U+005F (LOW LINE) are permitted anywhere in an
Unicode escape sequences are permitted in an
\
preceding the
u
and
{ }
code units, if they appear, do not contribute code points to the
\
Two
The definitions of the nonterminal
The nonterminal
_
via
The sets of code points with Unicode properties “ID_Start” and “ID_Continue” include, respectively, the code points with Unicode properties “Other_ID_Start” and “Other_ID_Continue”.
"$"
, or
"_"
, or the
"$"
, or
"_"
, or the
\
A reserved word is an
The
\
The following tokens are ECMAScript keywords and may not be used as
In some contexts
yield
and
await
are given the semantics of an
let
and
static
are treated as reserved words through static semantic restrictions (see
The following tokens are reserved for use as keywords in future language extensions.
Use of the following tokens within
implements
|
package
|
protected
|
|
interface
|
private
|
public
|
The
For example:
3in
is an error and not the two input elements
3
and
in
.
A conforming implementation, when processing
A numeric literal stands for a value of the Number type. This value is determined in two steps: first, a mathematical value (MV) is derived from the literal; second, this mathematical value is rounded as described below.
Once the exact MV for a numeric literal has been determined,
it is then rounded to a value of the Number type. If the MV is 0, then
the rounded value is
0
digit or the Number value for the MV of a literal produced by replacing each significant digit after the 20th with a
0
digit and then incrementing the literal at the 20th significant digit position. A digit is
significant
if it is not part of an
0
; or
A string literal is zero or more Unicode code points enclosed
in single or double quotes. Unicode code points may also be represented
by an escape sequence. All code points may appear literally in a string
literal except for the closing quote code points, U+005C (REVERSE
SOLIDUS), U+000D (CARRIAGE RETURN), and U+000A (LINE FEED). Any code
points may appear in the form of an escape sequence. String literals
evaluate to ECMAScript String values. When generating these String
values Unicode code points are UTF-16 encoded as defined in
A conforming implementation, when processing
The definition of the nonterminal
\n
or
\u000A
.
A string literal stands for a value of the String type. The
String value (SV) of the literal is described in terms of code unit
values contributed by the various parts of the string literal. As part
of this process, some Unicode code points within the string literal are
interpreted as having a mathematical value (MV), as described below or
in
| Escape Sequence | Code Unit Value | Unicode Character Name | Symbol |
|---|---|---|---|
\b
|
0x0008
|
BACKSPACE |
|
\t
|
0x0009
|
CHARACTER TABULATION |
|
\n
|
0x000A
|
LINE FEED (LF) |
|
\v
|
0x000B
|
LINE TABULATION |
|
\f
|
0x000C
|
FORM FEED (FF) |
|
\r
|
0x000D
|
CARRIAGE RETURN (CR) |
|
\"
|
0x0022
|
QUOTATION MARK |
"
|
\'
|
0x0027
|
APOSTROPHE |
'
|
\\
|
0x005C
|
REVERSE SOLIDUS |
\
|
A regular expression literal is an input element that is converted to a RegExp object (see
===
to each other even if the two literals' contents are identical. A RegExp object may also be created at runtime by
new RegExp
or calling the
RegExp
The productions below describe the syntax for a regular
expression literal and are used by the input element scanner to find the
end of the regular expression literal. The source text comprising the
An implementation may extend the ECMAScript Regular Expression grammar defined in
Regular expression literals may not be empty; instead of
representing an empty regular expression literal, the code unit sequence
//
starts a single-line comment. To specify an empty regular expression, use:
/(?:)/
.
A conforming implementation must not use the extended definition of
A template literal component is interpreted as a sequence of
Unicode code points. The Template Value (TV) of a literal component is
described in terms of code unit values (SV,
TV excludes the code units of
Most ECMAScript statements and declarations must be terminated with a semicolon. Such semicolons may always appear explicitly in the source text. For convenience, however, such semicolons may be omitted from the source text in certain situations. These situations are described by saying that semicolons are automatically inserted into the source code token stream in those situations.
In the following rules, “token” means the actual recognized lexical token determined using the current lexical
There are three basic rules of semicolon insertion:
When, as the source text is parsed from left to right, a token (called the offending token ) is encountered that is not allowed by any production of the grammar, then a semicolon is automatically inserted before the offending token if one or more of the following conditions is true:
}
.
)
and the inserted semicolon would then be parsed as the terminating semicolon of a do-while statement (
However, there is an additional overriding condition on the
preceding rules: a semicolon is never inserted automatically if the
semicolon would then be parsed as an empty statement or if that
semicolon would become one of the two semicolons in the header of a
for
statement (see
The following are the only restricted productions in the grammar:
The practical effect of these restricted productions is as follows:
++
or
--
token is encountered where the parser would treat it as a postfix operator, and at least one
++
or
--
token, then a semicolon is automatically inserted before the
++
or
--
token.
continue
,
break
,
return
,
throw
, or
yield
token is encountered and a
continue
,
break
,
return
,
throw
, or
yield
token.
The resulting practical advice to ECMAScript programmers is:
++
or
--
operator should appear on the same line as its operand.
return
or
throw
statement or an
yield
expression should start on the same line as the
return
,
throw
, or
yield
token.
break
or
continue
statement should be on the same line as the
break
or
continue
token.
The source
{
1
2
}
3
is not a valid sentence in the ECMAScript grammar, even with the automatic semicolon insertion rules. In contrast, the source
{
1
2
}
3
is also not a valid ECMAScript sentence, but is transformed by automatic semicolon insertion into the following:
{
1
;
2
;}
3
;
which is a valid ECMAScript sentence.
The source
for
(a; b
)
is not a valid ECMAScript sentence and is not altered by
automatic semicolon insertion because the semicolon is needed for the
header of a
for
statement. Automatic semicolon insertion never inserts one of the two semicolons in the header of a
for
statement.
The source
return
a + b
is transformed by automatic semicolon insertion into the following:
return
;
a + b;
The expression
a + b
is not treated as a value to be returned by the
return
statement, because a
return
.
The source
a = b
++c
is transformed by automatic semicolon insertion into the following:
a = b;
++c;
The token
++
is not treated as a postfix operator applying to the variable
b
, because a
b
and
++
.
The source
if
(a > b)
else
c = d
is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion before the
else
token, even though no production of the grammar applies at that point,
because an automatically inserted semicolon would then be parsed as an
empty statement.
The source
a = b + c
(d + e).print()
is not transformed by automatic semicolon insertion, because the parenthesized expression that begins the second line can be interpreted as an argument list for a function call:
a = b + c(d + e).print()
In the circumstance that an assignment statement must begin with a left parenthesis, it is a good idea for the programmer to provide an explicit semicolon at the end of the preceding statement rather than to rely on automatic semicolon insertion.
yield
and
await
are permitted as
let
await
0
;
"arguments"
or
"eval"
.
"yield"
.
"await"
.
"implements"
,
"interface"
,
"let"
,
"package"
,
"private"
,
"protected"
,
"public"
,
"static"
, or
"yield"
.
"await"
.
yield
or
await
.
StringValue of
"yield"
.
"await"
.
"eval"
or
"arguments"
, return
"yield"
.
"await"
.
With parameters value and environment .
var
statements and formal parameter lists of some non-strict functions (See
"yield"
,
value
,
environment
).
"await"
,
value
,
environment
).
"yield"
).
"await"
).
The result of evaluating an
In
yield
may be used as an identifier. Evaluating the
yield
as if it was an
When processing an instance of the production
the interpretation of
this
Keyword
See
false
, return
true
, return
An
Array elements may be elided at the beginning, middle or end of
the element list. Whenever a comma in the element list is not preceded
by an
With parameters array and nextIndex .
"length"
,
"length"
,
"length"
,
An object initializer is an expression describing the initialization of an Object, written in a form resembling a literal. It is a list of zero or more pairs of property keys and associated values, enclosed in curly brackets. The values need not be literals; they are evaluated each time the object initializer is evaluated.
In certain contexts,
In addition to describing an actual object initializer the
This production exists so that
With parameter symbol .
With parameter symbol .
Static semantic rules that depend upon substructure generally do not look into function definitions.
With parameters object and enumerable .
An alternative semantics for this production is given in
See
See
See
See
See
See
"g"
,
"i"
,
"m"
,
"s"
,
"u"
, or
"y"
, or if it contains the same code point more than once.
With parameter raw .
The abstract operation GetTemplateObject is called with a
"frozen"
).
"raw"
, PropertyDescriptor { [[Value]]:
rawObj
, [[Writable]]:
"frozen"
).
The creation of a template object cannot result in an
Each
Future editions of this specification may define additional non-enumerable properties of template objects.
The string conversion semantics applied to the
String.prototype.concat
rather than the
+
operator.
The string conversion semantics applied to the
String.prototype.concat
rather than the
+
operator.
The string conversion semantics applied to the
String.prototype.concat
rather than the
+
operator.
With parameter name .
This algorithm does not apply
delete
and
typeof
may be applied to parenthesized expressions.
When processing an instance of the production
With parameter symbol .
super
, return
Properties are accessed by name, using either the dot notation:
or the bracket notation:
The dot notation is explained by the following syntactic conversion:
is identical in its behaviour to
and similarly
is identical in its behaviour to
where <
identifier-name-string
> is the result of evaluating StringValue of
Is evaluated in exactly the same manner as
Is evaluated in exactly the same manner as
new
Operator
The abstract operation EvaluateNew with arguments constructExpr , and arguments performs the following steps:
"eval"
, then
A
The abstract operation EvaluateCall takes as arguments a value
func
, a value
ref
, a
super
Keyword
The abstract operation GetSuperConstructor performs the following steps:
The abstract operation MakeSuperPropertyReference with arguments actualThis , propertyKey , and strict performs the following steps:
The evaluation of an argument list produces a
A tagged template is a function call where the arguments of the call are derived from a
+
operator (see
-
operator (see
+
operator (see
-
operator (see
delete
Operator
It is a Syntax Error if the derived
and
The last rule means that expressions such as
delete (((foo)))
produce early errors because of recursive application of the first rule.
When a
delete
operator occurs within
delete
operator occurs within
void
Operator
typeof
Operator
"undefined"
.
| Type of val | Result |
|---|---|
| Undefined |
"undefined"
|
| Null |
"object"
|
| Boolean |
"boolean"
|
| Number |
"number"
|
| String |
"string"
|
| Symbol |
"symbol"
|
| Object (ordinary and does not implement [[Call]]) |
"object"
|
| Object (standard exotic and does not implement [[Call]]) |
"object"
|
| Object (implements [[Call]]) |
"function"
|
| Object (non-standard exotic and does not implement [[Call]]) |
Implementation-defined. Must not be
"undefined"
,
"boolean"
,
"function"
,
"number"
,
"symbol"
, or
"string"
.
|
Implementations are discouraged from defining new
typeof
result values for non-standard exotic objects. If possible
"object"
should be used for such objects.
+
Operator
The unary + operator converts its operand to Number type.
-
Operator
The unary
-
operator converts its operand to Number type and then negates it. Negating
~
)
!
)
**
Operator
Returns an implementation-dependent approximation of the result of raising base to the power exponent .
The result of
base
**
exponent
when
base
is
*
,
/
, or
%
) to
lnum
and
rnum
as specified in
*
Operator
The
*
The result of a floating-point multiplication is governed by the rules of IEEE 754-2008 binary double-precision arithmetic:
/
Operator
The
/
%
Operator
The
%
In C and C++, the remainder operator accepts only integral operands; in ECMAScript, it also accepts floating-point operands.
The result of a floating-point remainder operation as computed by the
%
operator is not the same as the “remainder” operation defined by IEEE
754-2008. The IEEE 754-2008 “remainder” operation computes the remainder
from a rounding division, not a truncating division, and so its
behaviour is not analogous to that of the usual integer remainder
operator. Instead the ECMAScript language defines
%
on
floating-point operations to behave in a manner analogous to that of the
Java integer remainder operator; this may be compared with the C
library function fmod.
The result of an ECMAScript floating-point remainder operation is determined by the rules of IEEE arithmetic:
+
)
The addition operator either performs string concatenation or numeric addition.
No hint is provided in the calls to
Step 7 differs from step 3 of the
-
)
The
+
operator performs addition when applied to two operands of numeric type, producing the sum of the operands. The
-
operator performs subtraction, producing the difference of two numeric operands.
Addition is a commutative operation, but not always associative.
The result of an addition is determined using the rules of IEEE 754-2008 binary double-precision arithmetic:
The
-
operator performs subtraction when applied
to two operands of numeric type, producing the difference of its
operands; the left operand is the minuend and the right operand is the
subtrahend. Given numeric operands
a
and
b
, it is always the case that
a - b
produces the same result as
a + (-b)
.
<<
)
Performs a bitwise left shift operation on the left operand by the amount specified by the right operand.
>>
)
Performs a sign-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
>>>
)
Performs a zero-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
The result of evaluating a relational operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
The
[In]
grammar parameter is needed to avoid confusing the
in
operator in a relational expression with the
in
operator in a
for
statement.
The abstract operation InstanceofOperator(
V
,
target
) implements the generic algorithm for determining if ECMAScript value
V
is an instance of object
target
either by consulting
target
's @@hasinstance method or, if absent, determining whether the value of
target
's
prototype
property is present in
V
's prototype chain. This abstract operation performs the following steps:
Steps 4 and 5 provide compatibility with previous editions of ECMAScript that did not use a @@hasInstance method to define the
instanceof
operator semantics. If an object does not define or inherit @@hasInstance it uses the default
instanceof
semantics.
The result of evaluating an equality operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
Given the above definition of equality:
"" + a == "" + b
.
+a == +b
.
!a == !b
.
The equality operators maintain the following invariants:
A != B
is equivalent to
!(A == B)
.
A == B
is equivalent to
B == A
, except in the order of evaluation of
A
and
B
.
The equality operator is not always transitive. For example,
there might be two distinct String objects, each representing the same
String value; each String object would be considered equal to the String
value by the
==
operator, but the two String objects would not be equal to each other. For example:
new String("a") == "a"
and
"a" == new String("a")
are both
new String("a") == new String("a")
is
Comparison of Strings uses a simple equality test on sequences of code unit values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore Strings values that are canonically equal according to the Unicode standard could test as unequal. In effect this algorithm assumes that both Strings are already in normalized form.
The production
The value produced by a
&&
or
||
operator is not necessarily of type Boolean. The value produced will always be the value of one of the two operand expressions.
? :
)
The grammar for a
@
where
@=
.
When an assignment occurs within
In certain circumstances when processing an instance of the production
With parameter value .
With parameter value .
With parameters value and excludedNames .
With parameter iteratorRecord .
Left to right evaluation order is maintained by evaluating a
With parameters value and propertyName .
,
)
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
With parameter labelSet .
A
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
At the top level of a function, or script, function declarations are treated like var declarations rather than like lexical declarations.
At the top level of a function or script, inner function declarations are treated like var declarations.
No matter how control leaves the
The value of a
eval
function all return the value 1:
eval
(
"1;;;;;"
)
eval
(
"1;{}"
)
eval
(
"1;var a;"
)
When a
BlockDeclarationInstantiation is performed as follows using arguments
code
and
env
.
code
is the
let
and
const
declarations define variables that are scoped to the
let
declaration does not have an
"let"
.
A
const
declaration.
A
var
statement declares variables that are scoped to the
If a
With parameters value and environment .
When
With parameters value and environment .
With parameters value , environment , and excludedNames .
With parameters iteratorRecord and environment .
When
With parameters value , environment , and propertyName .
When
An
function
or
class
keywords because that would make it ambiguous with a
async function
because that would make it ambiguous with an
let [
because that would make it ambiguous with a
let
if
Statement
Each
else
for which the choice of associated
if
is ambiguous shall be associated with the nearest possible
if
that would otherwise have no corresponding
else
.
It is only necessary to apply this rule if the extension specified in
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
This section is extended by Annex
It is only necessary to apply this rule if the extension specified in
The abstract operation LoopContinues with arguments completion and labelSet is defined by the following steps:
Within the
do
-
while
Statement
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
With parameter labelSet .
while
Statement
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
With parameter labelSet .
for
Statement
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
With parameter labelSet .
The abstract operation ForBodyEvaluation with arguments test , increment , stmt , perIterationBindings , and labelSet is performed as follows:
The abstract operation CreatePerIterationEnvironment with argument perIterationBindings is performed as follows:
for
-
in
,
for
-
of
, and
for
-
await
-
of
Statements
If
The last rule means that the other rules are applied even if parentheses surround
"let"
.
With parameter labelSet .
This section is extended by Annex
With parameter labelSet .
This section is extended by Annex
With parameters iterationSet and labelSet .
This section is extended by Annex
This section is extended by Annex
This section is extended by Annex
This section is extended by Annex
With parameters value and environment .
var
statements and the formal parameter lists of some non-strict functions (see
With parameter environment .
With parameter labelSet .
This section is extended by Annex
The abstract operation ForIn/OfHeadEvaluation is called with arguments
TDZnames
,
expr
, and
iterationKind
. The value of
iterationKind
is either
The abstract operation ForIn/OfBodyEvaluation is called with arguments
lhs
,
stmt
,
iteratorRecord
,
iterationKind
,
lhsKind
,
labelSet
, and optional argument
iteratorKind
. The value of
lhsKind
is either
When the abstract operation EnumerateObjectProperties is called with argument O , the following steps are taken:
next
method iterates over all the String-valued keys of enumerable properties of
O
.
The iterator object is never directly accessible to ECMAScript code.
The mechanics and order of enumerating the properties is not specified
but must conform to the rules specified below.
The iterator's
throw
and
return
methods are
next
method processes object properties to determine whether the property
key should be returned as an iterator value. Returned property keys do
not include keys that are Symbols. Properties of the target object may
be deleted during enumeration. A property that is deleted before it is
processed by the iterator's
next
method is ignored. If new
properties are added to the target object during enumeration, the newly
added properties are not guaranteed to be processed in the active
enumeration. A
next
method at most once in any enumeration.
Enumerating the properties of the target object includes
enumerating properties of its prototype, and the prototype of the
prototype, and so on, recursively; but a property of a prototype is not
processed if it has the same name as a property that has already been
processed by the iterator's
next
method. The values of
[[Enumerable]] attributes are not considered when determining if a
property of a prototype object has already been processed. The
enumerable property names of prototype objects must be obtained by
invoking EnumerateObjectProperties passing the prototype object as the
argument. EnumerateObjectProperties must obtain the own property keys of
the target object by calling its [[OwnPropertyKeys]] internal method.
Property attributes of the target object must be obtained by calling its
[[GetOwnProperty]] internal method.
The following is an informative definition of an ECMAScript generator function that conforms to these rules:
function
*
EnumerateObjectProperties
(
obj
)
{
const
visited =
new
Set
();
for
(
const
key
of
Reflect
.ownKeys(obj)) {
if
(
typeof
key ===
"symbol"
)
continue
;
const
desc =
Reflect
.getOwnPropertyDescriptor(obj, key);
if
(desc) {
visited.add(key);
if
(desc.enumerable)
yield
key;
}
}
const
proto =
Reflect
.getPrototypeOf(obj);
if
(proto ===
null
)
return
;
for
(
const
protoKey
of
EnumerateObjectProperties(proto)) {
if
(!visited.has(protoKey))
yield
protoKey;
}
}
continue
Statement
With parameters iterationSet and labelSet .
break
Statement
With parameter labelSet .
return
Statement
A
return
statement causes a function to cease execution and, in most cases, returns a value to the caller. If
return
statement may not actually return a value to the caller depending on surrounding context. For example, in a
try
block, a
return
statement's completion record may be replaced with another completion record during evaluation of the
finally
block.
with
Statement
The
with
statement adds an object
It is only necessary to apply the second rule if the extension specified in
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
No matter how control leaves the embedded
switch
Statement
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
With parameter input .
The abstract operation CaseClauseIsSelected, given
This operation does not execute
C
's
No matter how control leaves the
A
break
and
continue
statements. ECMAScript has no
goto
statement. A
An alternative definition for this rule is provided in
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
The abstract operation IsLabelledFunction with argument stmt performs the following steps:
With parameter labelSet .
throw
Statement
try
Statement
The
try
statement encloses a block of code in which an exceptional condition can occur, such as a runtime error or a
throw
statement. The
catch
clause provides the exception-handling code. When a catch clause catches an exception, its
An alternative
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
With parameter thrownValue .
No matter how control leaves the
debugger
Statement
Evaluating a
A
Directive Prologue
is the longest sequence of
A
Use Strict Directive
is an
"use strict"
or
'use strict'
. A
A
The
"eval"
or
"arguments"
.
The LexicallyDeclaredNames of a
Multiple occurrences of the same
"*default*"
».
"*default*"
is used within this specification as
a synthetic name for hoistable anonymous functions that are defined
using export declarations.
With parameter symbol .
Static semantic rules that depend upon substructure generally do not look into function definitions.
The ExpectedArgumentCount of a
The abstract operation IsAnonymousFunctionDefinition determines
if its argument is a function definition that does not bind a name. The
argument
expr
is the result of parsing an
With parameters
functionObject
and
With parameters iteratorRecord and environment .
When
The new
The new
With parameter scope .
"default"
).
An anonymous
export default
declaration, and its function code is therefore always
With parameter name .
An alternative semantics is provided in
The
A
prototype
property is automatically created for every function defined using a
When the production
is recognized the following grammar is used to refine the interpretation of
With parameter symbol .
super
or
this
, return
Normally, Contains does not look inside most function forms. However, Contains is used to detect
new.target
,
this
, and
super
usage within an
With parameters iteratorRecord and environment .
When
With parameters
functionObject
and
With parameter name .
An
arguments
,
super
,
this
, or
new.target
. Any reference to
arguments
,
super
,
this
, or
new.target
within an
super
, the
super
is always contained within a non-
super
is accessible via the
scope
that is captured by the
With parameter symbol .
With parameters object and optional parameter functionPrototype .
With parameters object and enumerable .
"get"
).
"set"
).
The syntactic context immediately following
yield
requires use of the
"eval"
or
"arguments"
.
"*default*"
».
"*default*"
is used within this specification as
a synthetic name for hoistable anonymous functions that are defined
using export declarations.
With parameter symbol .
With parameter symbol .
Static semantic rules that depend upon substructure generally do not look into function definitions.
With parameters
functionObject
and
"%GeneratorPrototype%"
, « [[GeneratorState]], [[GeneratorContext]] »).
With parameter scope .
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
"default"
).
An anonymous
export default
declaration, and its function code is therefore always
With parameters object and enumerable .
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
With parameter name .
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
The
"throw"
).
throw
method are propagated. Normal completions from an inner
throw
method are processed similarly to an inner
next
.
throw
method, this throw is going to terminate the
yield*
loop. But first we need to give
iterator
a chance to clean up.
yield*
protocol violation:
iterator
does not have a
throw
method.
"return"
).
eval
or the
arguments
.
"*default*"
».
"*default*"
is used within this specification as
a synthetic name for hoistable anonymous functions that are defined
using export declarations.
With parameter symbol .
With parameter symbol .
Static semantic rules that depend upon substructure generally do not look into function definitions.
With parameters
functionObject
and
"%AsyncGeneratorPrototype%"
, « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]] »).
With parameter scope .
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
"default"
).
An anonymous
export default
declaration.
With parameter object and enumerable .
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
With parameter name .
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
The
A class definition is always
It is a Syntax Error if
"constructor"
.
"constructor"
and HasDirectSuper of
"constructor"
and SpecialMethod of
"prototype"
.
"*default*"
».
"constructor"
, return
"constructor"
, return
Early Error rules ensure that there is only one method definition named
"constructor"
and that it is not an
With parameter symbol .
Static semantic rules that depend upon substructure generally do not look into class bodies except for
With parameter symbol .
"constructor"
, return a new empty
"constructor"
, return
list
.
With parameters classBinding and className .
constructor
(... args){
super
(...args);}
using the syntactic grammar with the
constructor
(){ }
using the syntactic grammar with the
"derived"
.
"constructor"
,
F
).
"default"
.
With parameter name .
await
is parsed as an
When
await
is parsed as a keyword and will be a Syntax error. When
await
may be parsed as an identifier when the
[
Unlike
"eval"
or
"arguments"
.
"*default*"
».
*default*
"
is used within this specification as a synthetic name for hoistable
anonymous functions that are defined using export declarations.
With parameter symbol .
With parameter symbol .
With parameter scope .
"default"
).
With parameters
functionObject
and
With parameters object and enumerable .
With parameter name .
When processing an instance of the production
With parameter symbol .
super
, or
this
, return
super
, or
this
, return
new.target
,
this
, and
super
usage within an AsyncArrowFunction.
With parameters iteratorRecord and environment .
With parameters
functionObject
and
With parameter name .
The abstract operation IsInTailPosition with argument call performs the following steps:
Tail Position calls are only defined in
With parameter call .
call
is a
The abstract operation PrepareForTailCall performs the following steps:
A tail position call must either release any transient internal resources associated with the currently executing function
For example, a tail position call should only grow an implementation's activation record stack by the amount that the size of the target function's activation record exceeds the size of the calling function's activation record. If the target function's activation record is smaller, then the total size of the stack should decrease.
super
unless the source code containing
super
is eval code that is being processed by a
super
within
At the top level of a
A
Script Record
encapsulates information about a script being evaluated. Each script record contains the fields listed in
| Field Name | Value Type | Meaning |
|---|---|---|
| [[Realm]] |
|
The
|
| [[Environment]] |
|
The
|
| [[ECMAScriptCode]] |
a
|
The result of parsing the source text of this module using
|
| [[HostDefined]] |
Any, default value is
|
Field reserved for use by host environments that need to associate additional information with a script. |
The abstract operation ParseScript with arguments
sourceText
,
realm
, and
hostDefined
creates a
An implementation may parse script source text and analyse it for Early Error conditions prior to evaluation of ParseScript for that script source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseScript upon that source text.
When an
GlobalDeclarationInstantiation is performed as follows using arguments
script
and
env
.
script
is the
Early errors specified in
Unlike explicit var or function declarations, properties that are directly created on the
The job ScriptEvaluationJob with parameters
sourceText
and
hostDefined
parses, validates, and evaluates
sourceText
as a
super
.
The duplicate ExportedNames rule implies that multiple
export default
With parameter labelSet .
With parameter labelSet .
With parameters iterationSet and labelSet .
ExportedBindings are the locally bound names that are explicitly associated with a
ExportedNames are the externally visible names that a
The abstract operation ImportedLocalNames with argument
importEntries
creates a
The LexicallyDeclaredNames of a
export
At the top level of a
export
export
A Module Record encapsulates structural information about the imports and exports of a single module. This information is used to link the imports and exports of sets of connected modules. A Module Record includes four fields that are only used when evaluating a module.
For specification purposes Module Record values are values of the
Module Record defines the fields listed in
| Field Name | Value Type | Meaning |
|---|---|---|
| [[Realm]] |
|
The
|
| [[Environment]] |
|
The
|
| [[Namespace]] |
Object |
|
The Module Namespace Object (
|
| [[HostDefined]] |
Any, default value is
|
Field reserved for use by host environments that need to associate additional information with a module. |
| Method | Purpose |
|---|---|
| GetExportedNames( exportStarSet ) | Return a list of all names that are either directly or indirectly exported from this module. |
| ResolveExport( exportName , resolveSet ) |
Return the binding of a name exported by this module. Bindings are represented by a
ResolvedBinding Record
, of the form { [[Module]]:
This operation must be idempotent if it completes normally. Each time it is called with a specific exportName , resolveSet pair as arguments it must return the same result. |
| Instantiate() |
Prepare the module for evaluation by transitively resolving all module dependencies and creating a module
|
| Evaluate() |
If this module has already been evaluated successfully, return
Instantiate must have completed successfully prior to invoking this method. |
A
Cyclic Module Record
is used to represent information about a module that can participate in
dependency cycles with other modules that are subclasses of the
In addition to the fields defined in
| Field Name | Value Type | Meaning |
|---|---|---|
| [[Status]] | String |
Initially
"uninstantiated"
. Transitions to
"instantiating"
,
"instantiated"
,
"evaluating"
,
"evaluated"
(in that order) as the module progresses throughout its lifecycle.
|
| [[EvaluationError]] |
An
|
A completion of type
"evaluated"
.
|
| [[DFSIndex]] |
Integer |
|
Auxiliary field used during Instantiate and Evaluate only.
If [[Status]] is
"instantiating"
or
"evaluating"
,
this nonnegative number records the point at which the module was first
visited during the ongoing depth-first traversal of the dependency
graph.
|
| [[DFSAncestorIndex]] |
Integer |
|
Auxiliary field used during Instantiate and Evaluate only. If [[Status]] is
"instantiating"
or
"evaluating"
, this is either the module's own [[DFSIndex]] or that of an "earlier" module in the same strongly connected component.
|
| [[RequestedModules]] |
|
A
|
In addition to the methods defined in
| Method | Purpose |
|---|---|
|
|
Initialize the
|
|
|
Initialize the
|
The Instantiate concrete method of a
On success, Instantiate transitions this module's [[Status]] from
"uninstantiated"
to
"instantiated"
. On failure, an exception is thrown and this module's [[Status]] remains
"uninstantiated"
.
This abstract method performs the following steps (most of the work is done by the auxiliary function
"instantiating"
or
"evaluating"
.
"instantiated"
or
"evaluated"
.
The InnerModuleInstantiation abstract operation is used by Instantiate to perform the actual instantiation process for the
"instantiated"
together.
This abstract operation performs the following steps:
"instantiating"
,
"instantiated"
, or
"evaluated"
, then
"uninstantiated"
.
"instantiating"
.
"instantiating"
,
"instantiated"
, or
"evaluated"
.
"instantiating"
if and only if
requiredModule
is in
stack
.
"instantiating"
, then
"instantiated"
.
The Evaluate concrete method of a
Evaluate transitions this module's [[Status]] from
"instantiated"
to
"evaluated"
.
If execution results in an exception, that exception is recorded in the [[EvaluationError]] field and rethrown by future invocations of Evaluate.
This abstract method performs the following steps (most of the work is done by the auxiliary function
"instantiated"
or
"evaluated"
.
"evaluated"
and
module
.[[EvaluationError]] is
The InnerModuleEvaluation abstract operation is used by Evaluate to perform the actual evaluation process for the
This abstract operation performs the following steps:
"evaluated"
, then
"evaluating"
, return
index
.
"instantiated"
.
"evaluating"
.
"evaluating"
or
"evaluated"
.
"evaluating"
if and only if
requiredModule
is in
stack
.
"evaluating"
, then
"evaluated"
.
This non-normative section gives a series of examples of the instantiation and evaluation of a few common module graphs, with a specific focus on how errors can occur.
First consider the following simple module graph:
Let's first assume that there are no error conditions. When a host first calls
A
.Instantiate(), this will complete successfully by assumption, and recursively instantiate modules
B
and
C
as well, such that
A
.[[Status]] =
B
.[[Status]] =
C
.[[Status]] =
"instantiated"
.
This preparatory step can be performed at any time. Later, when the
host is ready to incur any possible side effects of the modules, it can
call
A
.Evaluate(), which will complete successfully (again by assumption), recursively having evaluated first
C
and then
B
. Each module's [[Status]] at this point will be
"evaluated
".
Consider then cases involving instantiation errors. If
"uninstantiated"
.
C
's [[Status]] has become
"instantiated"
, though.
Finally, consider a case involving evaluation errors. If
"evaluated"
.
C
will also become
"evaluated"
but, in contrast to
A
and
B
,
will remain without an [[EvaluationError]], as it successfully
completed evaluation. Storing the exception ensures that any time a host
tries to reuse
A
or
B
by calling their Evaluate()
method, it will encounter the same exception. (Hosts are not required
to reuse Cyclic Module Records; similarly, hosts are not required to
expose the exception objects thrown by these methods. However, the
specification enables such uses.)
The difference here between instantiation and evaluation errors is due to how evaluation must be only performed once, as it can cause side effects; it is thus important to remember whether evaluation has already been performed, even if unsuccessfully. (In the error case, it makes sense to also remember the exception because otherwise subsequent Evaluate() calls would have to synthesize a new one.) Instantiation, on the other hand, is side-effect-free, and thus even if it fails, it can be retried at a later time with no issues.
Now consider a different type of error condition:
In this scenario, module
A
declares a dependency on some other module, but no
"uninstantiated"
.
Lastly, consider a module graph with a cycle:
Here we assume that the entry point is module
A
, so that the host proceeds by calling
A
.Instantiate(), which performs
"instantiating"
.
B
.[[Status]] itself remains
"instantiating"
when control gets back to
A
and
"instantiated"
, both
A
and
B
transition from
"instantiating"
to
"instantiated"
together; this is by design, since they form a strongly connected component.
An analogous story occurs for the evaluation phase of a cyclic module graph, in the success case.
Now consider a case where
A
has an instantiation error; for example, it tries to import a binding from
C
that does not exist. In that case, the above steps still occur, including the early return from the second call to
"instantiating"
). Hence both
A
and
B
become
"uninstantiated"
. Note that
C
is left as
"instantiated"
.
Finally, consider a case where
A
has an
evaluation error; for example, its source code throws an exception. In
that case, the evaluation-time analog of the above steps still occurs,
including the early return from the second call to
"evaluating"
). Hence both
A
and
B
become
"evaluated"
and the exception is recorded in both
A
and
B
's [[EvaluationError]] fields, while
C
is left as
"evaluated"
with no [[EvaluationError]].
A
Source Text Module Record
is used to represent information about a module that was defined from ECMAScript source text (
A
In addition to the fields defined in
| Field Name | Value Type | Meaning |
|---|---|---|
| [[ECMAScriptCode]] |
a
|
The result of parsing the source text of this module using
|
| [[ImportEntries]] |
|
A
|
| [[LocalExportEntries]] |
|
A
|
| [[IndirectExportEntries]] |
|
A
|
| [[StarExportEntries]] |
|
A
|
An
ImportEntry Record
is a
| Field Name | Value Type | Meaning |
|---|---|---|
| [[ModuleRequest]] | String |
String value of the
|
| [[ImportName]] | String |
The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. The value
"*"
indicates that the import request is for the target module's namespace object.
|
| [[LocalName]] | String | The name that is used to locally access the imported value from within the importing module. |
| Import Statement Form | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
|---|---|---|---|
import v from "mod";
|
"mod"
|
"default"
|
"v"
|
import * as ns from "mod";
|
"mod"
|
"*"
|
"ns"
|
import {x} from "mod";
|
"mod"
|
"x"
|
"x"
|
import {x as v} from "mod";
|
"mod"
|
"x"
|
"v"
|
import "mod";
|
An
|
||
An
ExportEntry Record
is a
| Field Name | Value Type | Meaning |
|---|---|---|
| [[ExportName]] | String | null | The name used to export this binding by this module. |
| [[ModuleRequest]] | String | null |
The String value of the
|
| [[ImportName]] | String | null |
The name under which the desired binding is exported by the module identified by [[ModuleRequest]].
"*"
indicates that the export request is for all exported bindings.
|
| [[LocalName]] | String | null |
The name that is used to locally access the exported value from within the importing module.
|
| Export Statement Form | [[ExportName]] | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
|---|---|---|---|---|
export var v;
|
"v"
|
|
|
"v"
|
export default function f(){}
|
"default"
|
|
|
"f"
|
export default function(){}
|
"default"
|
|
|
"*default*"
|
export default 42;
|
"default"
|
|
|
"*default*"
|
export {x};
|
"x"
|
|
|
"x"
|
export {v as x};
|
"x"
|
|
|
"v"
|
export {x} from "mod";
|
"x"
|
"mod"
|
"x"
|
|
export {v as x} from "mod";
|
"x"
|
"mod"
|
"v"
|
|
export * from "mod";
|
|
"mod"
|
"*"
|
|
The following definitions specify the required concrete methods and other
The abstract operation ParseModule with arguments
sourceText
,
realm
, and
hostDefined
creates a
"*"
, then
"*"
, then
"uninstantiated"
, [[EvaluationError]]:
An implementation may parse module source text and analyse it for Early Error conditions prior to the evaluation of ParseModule for that module source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseModule upon that source text.
The GetExportedNames concrete method of a
It performs the following steps:
"default"
) is
GetExportedNames does not filter out or throw an exception for names that have ambiguous star export bindings.
The ResolveExport concrete method of a
ResolveExport attempts to resolve an imported binding to
the actual defining module and local binding name. The defining module
may be the module represented by the
If a defining module is found, a
"ambiguous"
is returned.
This abstract method performs the following steps:
"default"
) is
default
export was not explicitly defined by this module.
default
export cannot be provided by an
export *
.
"ambiguous"
, return
"ambiguous"
.
*
import that includes the requested name.
"ambiguous"
.
The InitializeEnvironment concrete method of a
This abstract method performs the following steps:
"ambiguous"
, throw a
"*"
, then
"ambiguous"
, throw a
The ExecuteModule concrete method of a
This abstract method performs the following steps:
HostResolveImportedModule is an implementation-defined abstract operation that provides the concrete
The implementation of HostResolveImportedModule must conform to the following requirements:
Multiple different
referencingModule
,
specifier
pairs may map to the same
The GetModuleNamespace abstract operation retrieves the Module Namespace
This abstract operation performs the following steps:
"uninstantiated"
.
The only way GetModuleNamespace can throw is via one of the triggered
A TopLevelModuleEvaluationJob with parameters
sourceText
and
hostDefined
is a job that parses, validates, and evaluates
sourceText
as a
An implementation may parse a
sourceText
as a
The value of a
With parameter module .
"default"
, [[LocalName]]:
localName
}.
"*"
, [[LocalName]]:
localName
}.
"implements"
,
"interface"
,
"let"
,
"package"
,
"private"
,
"protected"
,
"public"
, or
"static"
.
The above rule means that each ReferencedBindings of
"*default*"
, append
"*default*"
to
declarationNames
.
"*default*"
, append
"*default*"
to
declarationNames
.
"*default*"
».
"default"
».
"*"
, [[LocalName]]:
"default"
}.
"default"
}.
"*default*"
, [[ExportName]]:
"default"
}.
"*default*"
is used within this specification as a synthetic name for anonymous default export values.
With parameter module .
It is not necessary to treat
export default
"*default*"
, then
"*default*"
,
value
,
env
).
"default"
.
"*default*"
,
value
,
env
).
An implementation must report most errors at the time the relevant ECMAScript language construct is evaluated. An
early error
is an error that can be detected and reported prior to the evaluation of any construct in the
eval
is called and prevent evaluation of the
eval
code. All errors that are not early errors are runtime errors.
An implementation must report as an
An implementation shall not treat other kinds of errors as early errors even if the compiler can prove that a construct cannot execute without error under any circumstances. An implementation may issue an early warning in such a case, but it should not report the error until the relevant construct is actually executed.
An implementation shall report all errors as specified, except for the following:
eval
, using a regular expression literal, or using the
Function
or
RegExp
HostReportErrors is an implementation-defined abstract operation that allows host environments to report parsing errors, early errors, and runtime errors.
An implementation of HostReportErrors must complete normally in all cases. The default implementation of HostReportErrors is to unconditionally return an empty normal completion.
errorList
will be a
An implementation must not extend this specification in the following ways:
"caller"
or
"arguments"
. Such own properties also must not be created for function objects defined using an
Function
Generator
AsyncFunction
bind
method also must not be created with such own properties.
"caller"
the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a
"caller"
.
Object.prototype.toLocaleString
,
Array.prototype.toLocaleString
,
Number.prototype.toLocaleString
,
Date.prototype.toLocaleDateString
,
Date.prototype.toLocaleString
,
Date.prototype.toLocaleTimeString
,
String.prototype.localeCompare
,
.prototype.toLocaleString
.
:
to immediately follow source text that matches the
There are certain built-in objects available whenever an ECMAScript
Unless specified otherwise, a built-in object that is callable as a function is a built-in
Many built-in objects are functions: they can be invoked with
arguments. Some of them furthermore are constructors: they are functions
intended for use with the
new
operator. For each built-in
function, this specification describes the arguments required by that
function and the properties of that
new
expression that invokes that
Unless otherwise specified in the description of a particular function, if a built-in function or
this
value” and “NewTarget” have the meanings given in
Unless otherwise specified in the description of a particular function, if a built-in function or
Implementations that add additional capabilities to the set of built-in functions are encouraged to do so by adding new functions rather than adding new parameters to existing functions.
Unless otherwise specified every built-in function and every built-in
Function.prototype
(
Unless otherwise specified every built-in prototype object has the
Object prototype object, which is the initial value of the expression
Object.prototype
(
Built-in function objects that are not identified as constructors do not implement the [[Construct]] internal method unless otherwise specified in the description of a particular function.
Each built-in function defined in this specification is created by calling the
Every built-in
"length"
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description. Optional parameters
(which are indicated with brackets:
[
]
) or rest parameters (which are shown using the form «...name») are not included in the default argument count.
For example, the
map
property of the Array prototype object is described under the subclause
heading «Array.prototype.map (callbackFn [ , thisArg])» which shows the
two named arguments callbackFn and thisArg, the latter being optional;
therefore the value of the
"length"
property of that
Unless otherwise specified, the
"length"
property of a built-in
Every built-in
name
property whose value is a String. Unless otherwise specified, this
value is the name that is given to the function in this specification.
For functions that are specified as properties of objects, the name
value is the
"get "
or
"set "
prepended to the
name
property is explicitly specified for each built-in functions whose property key is a Symbol value.
Unless otherwise specified, the
name
property of a built-in
Every other
Every
The global object :
new
operator.
The value of
Infinity
is
The value of
NaN
is
The value of
undefined
is
The
eval
function is the
%eval%
intrinsic object. When the
eval
function is called with one argument
x
, the following steps are taken:
The abstract operation PerformEval with arguments x , evalRealm , strictCaller , and direct performs the following steps:
"derived"
, let
inDerivedConstructor
be
eval
function.
The eval code cannot instantiate variable or function
bindings in the variable environment of the calling context that invoked
the eval if the calling context is evaluating formal parameter
initializers or if either the code of the calling context or the eval
code is
let
,
const
, or
class
declarations are always instantiated in a new LexicalEnvironment.
These
These
These
HostEnsureCanCompileStrings is an implementation-defined abstract operation that allows host environments to block certain ECMAScript functions which allow developers to compile strings into ECMAScript code.
An implementation of HostEnsureCanCompileStrings may complete normally or abruptly. Any abrupt completions will be propagated to its callers. The default implementation of HostEnsureCanCompileStrings is to unconditionally return an empty normal completion.
When the abstract operation EvalDeclarationInstantiation is called with arguments body , varEnv , lexEnv , and strict , the following steps are taken:
eval
will not create a global var declaration that would be shadowed by a global lexical declaration.
An alternative version of this algorithm is described in
The
isFinite
function is the
%isFinite%
intrinsic object. When the
isFinite
function is called with one argument
number
, the following steps are taken:
The
isNaN
function is the
%isNaN%
intrinsic object. When the
isNaN
function is called with one argument
number
, the following steps are taken:
A reliable way for ECMAScript code to test if a value
X
is a
X !== X
. The result will be
X
is a
The
parseFloat
function produces a Number value dictated by interpretation of the contents of the
string
argument as a decimal literal.
The
parseFloat
function is the
%parseFloat%
intrinsic object. When the
parseFloat
function is called with one argument
string
, the following steps are taken:
parseFloat
may interpret only a leading portion of
string
as a Number value; it ignores any code units that cannot be interpreted
as part of the notation of a decimal literal, and no indication is
given that any such code units were ignored.
The
parseInt
function produces an integer value dictated by interpretation of the contents of the
string
argument according to the specified
radix
. Leading white space in
string
is ignored. If
radix
is
0x
or
0X
, in which case a radix of 16 is assumed. If
radix
is 16, the number may also optionally begin with the code unit pairs
0x
or
0X
.
The
parseInt
function is the
%parseInt%
intrinsic object. When the
parseInt
function is called, the following steps are taken:
"0x"
or
"0X"
, then
parseInt
may interpret only a leading portion of
string
as an integer value; it ignores any code units that cannot be
interpreted as part of the notation of an integer, and no indication is
given that any such code units were ignored.
Uniform Resource Identifiers, or URIs, are Strings that
identify resources (e.g. web pages or files) and transport protocols by
which to access them (e.g. HTTP or FTP) on the Internet. The ECMAScript
language itself does not provide any support for using URIs except for
functions that encode and decode URIs as described in
Many implementations of ECMAScript provide additional functions and methods that manipulate web pages; these functions are beyond the scope of this standard.
A URI is composed of a sequence of components separated by component separators. The general form is:
:
/
;
?
where the italicized names represent components and “
:
”, “
/
”, “
;
” and “
?
” are reserved for use as separators. The
encodeURI
and
decodeURI
functions are intended to work with complete URIs; they assume that any
reserved code units in the URI are intended to have special meaning and
so are not encoded. The
encodeURIComponent
and
decodeURIComponent
functions are intended to work with the individual component parts of a
URI; they assume that any reserved code units represent text and so
must be encoded so that they are not interpreted as reserved code units
when the component is part of a complete URI.
The following lexical grammar specifies the form of encoded URIs.
The above syntax is based upon RFC 2396 and does not reflect changes introduced by the more recent RFC 3986.
When a code unit to be included in a URI is not listed above
or is not intended to have the special meaning sometimes given to the
reserved code units, that code unit must be encoded. The code unit is
transformed into its UTF-8 encoding, with
"%xx"
.
The encoding and escaping process is described by the abstract operation Encode taking two String arguments string and unescapedSet .
"%"
The unescaping and decoding process is described by the abstract operation Decode taking two String arguments string and reservedSet .
This syntax of Uniform Resource Identifiers is based upon RFC 2396 and does not reflect the more recent RFC 3986 which replaces RFC 2396. A formal description and implementation of UTF-8 is given in RFC 3629.
In UTF-8, characters are encoded using sequences of 1 to 6
octets. The only octet of a sequence of one has the higher-order bit
set to 0, the remaining 7 bits being used to encode the character value.
In a sequence of n octets, n > 1, the initial octet has the n
higher-order bits set to 1, followed by a bit set to 0. The remaining
bits of that octet contain bits from the value of the character to be
encoded. The following octets all have the higher-order bit set to 1 and
the following bit set to 0, leaving 6 bits in each to contain bits from
the character to be encoded. The possible UTF-8 encodings of ECMAScript
characters are specified in
| Code Unit Value | Representation | 1 st Octet | 2 nd Octet | 3 rd Octet | 4 th Octet |
|---|---|---|---|---|---|
0x0000 - 0x007F
|
00000000 0
zzzzzzz
|
0
zzzzzzz
|
|||
0x0080 - 0x07FF
|
00000
yyy yyzzzzzz
|
110
yyyyy
|
10
zzzzzz
|
||
0x0800 - 0xD7FF
|
xxxxyyyy yyzzzzzz
|
1110
xxxx
|
10
yyyyyy
|
10
zzzzzz
|
|
0xD800 - 0xDBFF
followed by 0xDC00 - 0xDFFF
|
110110
vv vvwwwwxx
followed by
110111
yy yyzzzzzz
|
11110
uuu
|
10
uuwwww
|
10
xxyyyy
|
10
zzzzzz
|
0xD800 - 0xDBFF
not followed by 0xDC00 - 0xDFFF
|
causes
URIError
|
||||
0xDC00 - 0xDFFF
|
causes
URIError
|
||||
0xE000 - 0xFFFF
|
xxxxyyyy yyzzzzzz
|
1110
xxxx
|
10
yyyyyy
|
10
zzzzzz
|
Where
uuuuu
=
vvvv
+ 1
to account for the addition of 0x10000 as in section 3.8 of the Unicode Standard (Surrogates).
The above transformation combines each
RFC 3629 prohibits the decoding of invalid UTF-8 octet
sequences. For example, the invalid sequence C0 80 must not decode into
the code unit 0x0000. Implementations of the Decode algorithm are
required to throw a
The
decodeURI
function computes a new version of
a URI in which each escape sequence and UTF-8 encoding of the sort that
might be introduced by the
encodeURI
function is replaced
with the UTF-16 encoding of the code points that it represents. Escape
sequences that could not have been introduced by
encodeURI
are not replaced.
The
decodeURI
function is the
%decodeURI%
intrinsic object. When the
decodeURI
function is called with one argument
encodedURI
, the following steps are taken:
"#"
.
The code point
"#"
is not decoded from escape sequences even though it is not a reserved URI code point.
The
decodeURIComponent
function computes a new
version of a URI in which each escape sequence and UTF-8 encoding of the
sort that might be introduced by the
encodeURIComponent
function is replaced with the UTF-16 encoding of the code points that it represents.
The
decodeURIComponent
function is the
%decodeURIComponent%
intrinsic object. When the
decodeURIComponent
function is called with one argument
encodedURIComponent
, the following steps are taken:
The
encodeURI
function computes a new version of a UTF-16 encoded (
The
encodeURI
function is the
%encodeURI%
intrinsic object. When the
encodeURI
function is called with one argument
uri
, the following steps are taken:
"#"
.
The code unit
"#"
is not encoded to an escape sequence even though it is not a reserved or unescaped URI code point.
The
encodeURIComponent
function computes a new version of a UTF-16 encoded (
The
encodeURIComponent
function is the
%encodeURIComponent%
intrinsic object. When the
encodeURIComponent
function is called with one argument
uriComponent
, the following steps are taken:
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
The Object
Object
property of the
extends
clause of a class definition.
When the
Object
function is called with optional argument
value
, the following steps are taken:
"%ObjectPrototype%"
).
The
"length"
property of the
Object
The Object
"length"
property.
The
assign
function is used to copy the values of all of the enumerable own properties from one or more source objects to a
target
object. When the
assign
function is called, the following steps are taken:
The
"length"
property of the
assign
function is 2.
The
create
function creates a new object with a specified prototype. When the
create
function is called, the following steps are taken:
The
defineProperties
function is used to add own properties and/or update the attributes of existing own properties of an object. When the
defineProperties
function is called, the following steps are taken:
The abstract operation ObjectDefineProperties with arguments O and Properties performs the following steps:
The
defineProperty
function is used to add an own property and/or update the attributes of an existing own property of an object. When the
defineProperty
function is called, the following steps are taken:
When the
entries
function is called with argument
O
, the following steps are taken:
When the
freeze
function is called, the following steps are taken:
"frozen"
).
When the
fromEntries
method is called with argument
iterable
, the following steps are taken:
A CreateDataPropertyOnObject function is an anonymous built-in function. When a CreateDataPropertyOnObject function is called with arguments key and value , the following steps are taken:
When the
getOwnPropertyDescriptor
function is called, the following steps are taken:
When the
getOwnPropertyDescriptors
function is called, the following steps are taken:
When the
getOwnPropertyNames
function is called, the following steps are taken:
When the
getOwnPropertySymbols
function is called with argument
O
, the following steps are taken:
The abstract operation GetOwnPropertyKeys is called with arguments O and type where O is an Object and type is one of the ECMAScript specification types String or Symbol. The following steps are taken:
When the
getPrototypeOf
function is called with argument
O
, the following steps are taken:
When the
is
function is called with arguments
value1
and
value2
, the following steps are taken:
When the
isExtensible
function is called with argument
O
, the following steps are taken:
When the
isFrozen
function is called with argument
O
, the following steps are taken:
"frozen"
).
When the
isSealed
function is called with argument
O
, the following steps are taken:
"sealed"
).
When the
keys
function is called with argument
O
, the following steps are taken:
When the
preventExtensions
function is called, the following steps are taken:
The initial value of
Object.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
When the
seal
function is called, the following steps are taken:
"sealed"
).
When the
setPrototypeOf
function is called with arguments
O
and
proto
, the following steps are taken:
When the
values
function is called with argument
O
, the following steps are taken:
The Object prototype object:
The initial value of
Object.prototype.constructor
is the intrinsic object
When the
hasOwnProperty
method is called with argument
V
, the following steps are taken:
The ordering of steps 1 and 2 is chosen to ensure that any
exception that would have been thrown by step 1 in previous editions of
this specification will continue to be thrown even if the
When the
isPrototypeOf
method is called with argument
V
, the following steps are taken:
The ordering of steps 1 and 2 preserves the behaviour specified by previous editions of this specification for the case where
V
is not an object and the
When the
propertyIsEnumerable
method is called with argument
V
, the following steps are taken:
This method does not consider objects in the prototype chain.
The ordering of steps 1 and 2 is chosen to ensure that any
exception that would have been thrown by step 1 in previous editions of
this specification will continue to be thrown even if the
When the
toLocaleString
method is called, the following steps are taken:
"toString"
).
The optional parameters to this function are not used but are intended to correspond to the parameter pattern used by ECMA-402
toLocaleString
functions. Implementations that do not include ECMA-402 support must not use those parameter positions for other purposes.
This function provides a generic
toLocaleString
implementation for objects that have no locale-specific
toString
behaviour.
Array
,
Number
,
Date
, and
Typed Arrays
provide their own locale-sensitive
toLocaleString
methods.
ECMA-402 intentionally does not provide an alternative to this default implementation.
When the
toString
method is called, the following steps are taken:
"[object Undefined]"
.
"[object Null]"
.
"Array"
.
"String"
.
"Arguments"
.
"Function"
.
"Error"
.
"Boolean"
.
"Number"
.
"Date"
.
"RegExp"
.
"Object"
.
"[object "
,
tag
, and
"]"
.
This function is the %ObjProto_toString% intrinsic object.
Historically, this function was occasionally used to access
the String value of the [[Class]] internal slot that was used in
previous editions of this specification as a nominal type tag for
various built-in objects. The above definition of
toString
preserves compatibility for legacy code that uses
toString
as a test for those specific kinds of built-in objects. It does not
provide a reliable type testing mechanism for other kinds of built-in or
program defined objects. In addition, programs can use @@toStringTag in
ways that will invalidate the reliability of such legacy type tests.
When the
valueOf
method is called, the following steps are taken:
This function is the %ObjProto_valueOf% intrinsic object.
Object instances have no special properties beyond those inherited from the Object prototype object.
The Function
Function
property of the
Function(…)
is equivalent to the object creation expression
new Function(…)
with the same arguments.
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
Function
behaviour must include a
super
call to the
Function
Function
. There is no syntactic means to create instances of
Function
subclasses except for the built-in
GeneratorFunction
,
AsyncFunction
, and
AsyncGeneratorFunction
subclasses.
The last argument specifies the body (executable code) of a function; any preceding arguments specify formal parameters.
When the
Function
function is called with some arguments
p1
,
p2
, … ,
pn
,
body
(where
n
might be 0, that is, there are no “
p
” arguments, and where
body
might also not be provided), the following steps are taken:
"normal"
,
args
).
It is permissible but not necessary to have one argument for each formal parameter to be specified. For example, all three of the following expressions produce the same result:
new
Function
(
"a"
,
"b"
,
"c"
,
"return a+b+c"
)
new
Function
(
"a, b, c"
,
"return a+b+c"
)
new
Function
(
"a,b"
,
"c"
,
"return a+b+c"
)
The abstract operation CreateDynamicFunction is called with arguments
constructor
,
newTarget
,
kind
, and
args
.
constructor
is the
new
was initially applied to,
kind
is either
"normal"
,
"generator"
,
"async"
, or
"async generator"
, and
args
is a
"normal"
, then
"%FunctionPrototype%"
.
"generator"
, then
"%Generator%"
.
"async"
, then
"%AsyncFunctionPrototype%"
.
"async generator"
.
"%AsyncGenerator%"
.
","
(a comma), and
nextArgString
.
"generator"
or
"async generator"
, then
"async"
or
"async generator"
, then
"generator"
, then
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
"async generator"
, then
"prototype"
, PropertyDescriptor { [[Value]]:
prototype
, [[Writable]]:
"normal"
, perform
"prototype"
property.
"anonymous"
).
" anonymous("
,
P
, 0x000A (LINE FEED),
") {"
, 0x000A (LINE FEED),
bodyText
, 0x000A (LINE FEED), and
"}"
.
A
prototype
property is created for every
non-async function created using CreateDynamicFunction to provide for
the possibility that the function will be used as a
| Kind | Prefix |
|---|---|
"normal"
|
"function"
|
"generator"
|
"function*"
|
"async"
|
"async function"
|
"async generator"
|
"async function*"
|
The Function
This is a
The value of
Function.prototype
is
This property has the attributes { [[Writable]]:
The Function prototype object:
new
operator.
prototype
property.
"length"
property whose value is 0.
name
property whose value is the empty String.
The Function prototype object is specified to be a
When the
apply
method is called with arguments
thisArg
and
argArray
, the following steps are taken:
The
thisArg
value is passed without modification as the
If
func
is an arrow function or a
When the
bind
method is called with argument
thisArg
and zero or more
args
, it performs the following steps:
"length"
).
"name"
).
"bound"
).
Function objects created using
Function.prototype.bind
are exotic objects. They also do not have a
prototype
property.
If
Target
is an arrow function or a
When the
call
method is called with argument
thisArg
and zero or more
args
, the following steps are taken:
The
thisArg
value is passed without modification as the
If
func
is an arrow function or a
The initial value of
Function.prototype.constructor
is the intrinsic object
When the
toString
method is called, the following steps are taken:
name
property of
func
.
When the
@@hasInstance
method of an object
F
is called with value
V
, the following steps are taken:
The value of the
name
property of this function is
"[Symbol.hasInstance]"
.
This property has the attributes { [[Writable]]:
This is the default implementation of
@@hasInstance
that most functions inherit.
@@hasInstance
is called by the
instanceof
operator to determine whether a value is an instance of a specific
v
instanceof
F
evaluates as
F[@@hasInstance](v)
A
instanceof
by exposing a different
@@hasInstance
method on the function.
This property is non-writable and non-configurable to prevent
tampering that could be used to globally expose the target function of a
Every Function instance is an ECMAScript
Function.prototype.bind
method (
Function instances have the following properties:
The value of the
"length"
property is an integer
that indicates the typical number of arguments expected by the
function. However, the language permits the function to be invoked with
some other number of arguments. The behaviour of a function when invoked
on a number of arguments other than the number specified by its
"length"
property depends on the function. This property has the attributes { [[Writable]]:
The value of the
name
property is a String that is descriptive of the function. The name has no semantic significance but is typically a variable or
Anonymous functions objects that do not have a contextual name associated with them by this specification do not have a
name
own property but inherit the
name
property of
Function instances that can be used as a
prototype
property. Whenever such a Function instance is created another ordinary
object is also created and is the initial value of the function's
prototype
property. Unless otherwise specified, the value of the
prototype
property is used to initialize the [[Prototype]] internal slot of the object created when that function is invoked as a
This property has the attributes { [[Writable]]:
Function objects created using
Function.prototype.bind
, or by evaluating a
prototype
property.
HostHasSourceTextAvailable is an implementation-defined abstract operation that allows host environments to prevent the source text from being provided for a given function.
An implementation of HostHasSourceTextAvailable must complete
normally in all cases. This operation must be deterministic with respect
to its parameters. Each time it is called with a specific
func
as its argument, it must return the same completion record. The default
implementation of HostHasSourceTextAvailable is to unconditionally
return a normal completion with a value of
The Boolean
Boolean
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
Boolean
behaviour must include a
super
call to the
Boolean
When
Boolean
is called with argument
value
, the following steps are taken:
"%BooleanPrototype%"
, « [[BooleanData]] »).
The Boolean
The initial value of
Boolean.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The Boolean prototype object:
The abstract operation thisBooleanValue ( value ) performs the following steps:
The initial value of
Boolean.prototype.constructor
is the intrinsic object
The following steps are taken:
"true"
; else return
"false"
.
The following steps are taken:
Boolean instances are ordinary objects that inherit properties from the Boolean prototype object. Boolean instances have a [[BooleanData]] internal slot. The [[BooleanData]] internal slot is the Boolean value represented by this Boolean object.
The Symbol
Symbol
property of the
new
operator.
extends
clause of a class definition but a
super
call to it will cause an exception.
When
Symbol
is called with optional argument
description
, the following steps are taken:
The Symbol
The initial value of
Symbol.asyncIterator
is the well known symbol @@asyncIterator (
This property has the attributes { [[Writable]]:
When
Symbol.for
is called with argument
key
it performs the following steps:
The GlobalSymbolRegistry is a
The initial value of
Symbol.hasInstance
is the well-known symbol @@hasInstance (
This property has the attributes { [[Writable]]:
The initial value of
Symbol.isConcatSpreadable
is the well-known symbol @@isConcatSpreadable (
This property has the attributes { [[Writable]]:
The initial value of
Symbol.iterator
is the well-known symbol @@iterator (
This property has the attributes { [[Writable]]:
When
Symbol.keyFor
is called with argument
sym
it performs the following steps:
The initial value of
Symbol.match
is the well-known symbol @@match (
This property has the attributes { [[Writable]]:
The initial value of
Symbol.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The initial value of
Symbol.replace
is the well-known symbol @@replace (
This property has the attributes { [[Writable]]:
The initial value of
Symbol.search
is the well-known symbol @@search (
This property has the attributes { [[Writable]]:
The initial value of
Symbol.species
is the well-known symbol @@species (
This property has the attributes { [[Writable]]:
The initial value of
Symbol.split
is the well-known symbol @@split (
This property has the attributes { [[Writable]]:
The initial value of
Symbol.toPrimitive
is the well-known symbol @@toPrimitive (
This property has the attributes { [[Writable]]:
The initial value of
Symbol.toStringTag
is the well-known symbol @@toStringTag (
This property has the attributes { [[Writable]]:
The initial value of
Symbol.unscopables
is the well-known symbol @@unscopables (
This property has the attributes { [[Writable]]:
The Symbol prototype object:
The abstract operation thisSymbolValue ( value ) performs the following steps:
The initial value of
Symbol.prototype.constructor
is the intrinsic object
Symbol.prototype.description
is an
The following steps are taken:
When the abstract operation SymbolDescriptiveString is called with argument sym , the following steps are taken:
"Symbol("
,
desc
, and
")"
.
The following steps are taken:
This function is called by ECMAScript language operators to
convert a Symbol object to a primitive value. The allowed values for
hint
are
"default"
,
"number"
, and
"string"
.
When the
@@toPrimitive
method is called with argument
hint
, the following steps are taken:
The value of the
name
property of this function is
"[Symbol.toPrimitive]"
.
This property has the attributes { [[Writable]]:
The initial value of the @@toStringTag property is the String value
"Symbol"
.
This property has the attributes { [[Writable]]:
Symbol instances are ordinary objects that inherit properties from the Symbol prototype object. Symbol instances have a [[SymbolData]] internal slot. The [[SymbolData]] internal slot is the Symbol value represented by this Symbol object.
Instances of Error objects are thrown as exceptions when runtime errors occur. The Error objects may also serve as base objects for user-defined exception classes.
The Error
Error
property of the
Error(…)
is equivalent to the object creation expression
new Error(…)
with the same arguments.
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
Error
behaviour must include a
super
call to the
Error
When the
Error
function is called with argument
message
, the following steps are taken:
"%ErrorPrototype%"
, « [[ErrorData]] »).
"message"
,
msgDesc
).
The Error
The initial value of
Error.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The Error prototype object:
The initial value of
Error.prototype.constructor
is the intrinsic object
The initial value of
Error.prototype.message
is the empty String.
The initial value of
Error.prototype.name
is
"Error"
.
The following steps are taken:
"name"
).
"Error"
; otherwise set
name
to ?
"message"
).
Error instances are ordinary objects that inherit properties
from the Error prototype object and have an [[ErrorData]] internal slot
whose value is
Object.prototype.toString
.
A new instance of one of the
NativeError
objects below is thrown when a runtime error is detected. All of these objects share the same structure, as described in
This exception is not currently used within this specification. This object remains for compatibility with previous editions of this specification.
Indicates a value that is not in the set or range of allowable values.
Indicate that an invalid reference value has been detected.
Indicates that a parsing error has occurred.
TypeError is used to indicate an unsuccessful operation when none of the other NativeError objects are an appropriate indication of the failure cause.
Indicates that one of the global URI handling functions was used in a way that is incompatible with its definition.
When an ECMAScript implementation detects a runtime error, it throws a new instance of one of the
NativeError
objects defined in
name
property of the prototype object, and in the implementation-defined
message
property of the prototype object.
For each error object, references to
NativeError
in the definition should be replaced with the appropriate error object name from
Each
NativeError
NativeError
(…)
is equivalent to the object creation expression
new
NativeError
(…)
with the same arguments.
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
NativeError
behaviour must include a
super
call to the
NativeError
When a NativeError function is called with argument message , the following steps are taken:
"%
NativeError
Prototype%"
, « [[ErrorData]] »).
"message"
,
msgDesc
).
The actual value of the string passed in step 2 is either
"%EvalErrorPrototype%"
,
"%RangeErrorPrototype%"
,
"%ReferenceErrorPrototype%"
,
"%SyntaxErrorPrototype%"
,
"%TypeErrorPrototype%"
, or
"%URIErrorPrototype%"
corresponding to which
NativeError
Each
NativeError
name
property whose value is the String value `"
NativeError
"`.
The initial value of
NativeError
.prototype
is a
NativeError
prototype object (
This property has the attributes { [[Writable]]:
Each NativeError prototype object:
The initial value of the
constructor
property of the prototype for a given
NativeError
The initial value of the
message
property of the prototype for a given
NativeError
The initial value of the
name
property of the prototype for a given
NativeError
NativeError
instances are ordinary objects that inherit properties from their
NativeError
prototype object and have an [[ErrorData]] internal slot whose value is
Object.prototype.toString
(
The Number
Number
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
Number
behaviour must include a
super
call to the
Number
When
Number
is called with argument
value
, the following steps are taken:
"%NumberPrototype%"
, « [[NumberData]] »).
The Number
The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1 that is representable as a Number value, which is approximately 2.2204460492503130808472633361816 x 10 - 16 .
This property has the attributes { [[Writable]]:
When
Number.isFinite
is called with one argument
number
, the following steps are taken:
When
Number.isInteger
is called with one argument
number
, the following steps are taken:
When
Number.isNaN
is called with one argument
number
, the following steps are taken:
This function differs from the global isNaN function (
When
Number.isSafeInteger
is called with one argument
number
, the following steps are taken:
The value of
Number.MAX_SAFE_INTEGER
is the largest integer n such that n and n + 1 are both exactly representable as a Number value.
The value of Number.MAX_SAFE_INTEGER is 9007199254740991 (2 53 - 1).
This property has the attributes { [[Writable]]:
The value of
Number.MAX_VALUE
is the largest positive finite value of the Number type, which is approximately
This property has the attributes { [[Writable]]:
The value of
Number.MIN_SAFE_INTEGER
is the smallest integer n such that n and n - 1 are both exactly representable as a Number value.
The value of Number.MIN_SAFE_INTEGER is -9007199254740991 (-(2 53 - 1)).
This property has the attributes { [[Writable]]:
The value of
Number.MIN_VALUE
is the smallest positive value of the Number type, which is approximately
In the IEEE 754-2008 double precision binary representation,
the smallest possible value is a denormalized number. If an
implementation does not support denormalized values, the value of
Number.MIN_VALUE
must be the smallest non-zero positive value that can actually be represented by the implementation.
This property has the attributes { [[Writable]]:
The value of
Number.NaN
is
This property has the attributes { [[Writable]]:
The value of Number.NEGATIVE_INFINITY is
This property has the attributes { [[Writable]]:
The value of the
Number.parseFloat
parseFloat
property of the
The value of the
Number.parseInt
parseInt
property of the
The value of Number.POSITIVE_INFINITY is
This property has the attributes { [[Writable]]:
The initial value of
Number.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The Number prototype object:
Unless explicitly stated otherwise, the methods of the Number prototype object defined below are not generic and the
The abstract operation thisNumberValue ( value ) performs the following steps:
The phrase “this Number value” within the specification of a
method refers to the result returned by calling the abstract operation
The initial value of
Number.prototype.constructor
is the intrinsic object
Return a String containing this Number value represented in
decimal exponential notation with one digit before the significand's
decimal point and
fractionDigits
digits after the significand's decimal point. If
fractionDigits
is
"NaN"
.
"-"
.
"Infinity"
.
"."
, and
b
.
"+"
.
"0"
.
"+"
.
"-"
.
"e"
,
c
, and
d
.
For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step 10.b.i be used as a guideline:
toFixed
returns a String containing this Number value represented in decimal fixed-point notation with
fractionDigits
digits after the decimal point. If
fractionDigits
is
The following steps are performed:
"NaN"
.
"-"
.
"0"
. Otherwise, let
m
be the String value consisting of the digits of the decimal representation of
n
(in order, with no leading zeroes).
"."
, and
b
.
The output of
toFixed
may be more precise than
toString
for some values because toString only prints enough significant digits
to distinguish the number from adjacent number values. For example,
(1000000000000000128).toString()
returns
"1000000000000000100"
, while
(1000000000000000128).toFixed(0)
returns
"1000000000000000128"
.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the
Number.prototype.toLocaleString
method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following
specification of the
toLocaleString
method is used.
Produces a String value that represents this Number value
formatted according to the conventions of the host environment's current
locale. This function is implementation-dependent, and it is
permissible, but not encouraged, for it to return the same thing as
toString
.
The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
Return a String containing this Number value represented
either in decimal exponential notation with one digit before the
significand's decimal point and
"NaN"
.
"Infinity"
.
"."
, and
b
.
The optional
radix
should be an integer value in the inclusive range 2 to 36. If
radix
is not present or is
The following steps are performed:
a
-
z
are used for digits with values 10 through 35. The precise algorithm is
implementation-dependent, however the algorithm should be a
generalization of that specified in
The
toString
function is not generic; it throws a
The
"length"
property of the
toString
method is 1.
Number instances are ordinary objects that inherit properties from the Number prototype object. Number instances also have a [[NumberData]] internal slot. The [[NumberData]] internal slot is the Number value represented by this Number object.
The Math object:
Math
property of the
new
operator.
In this specification, the phrase “the Number value for
x
” has a technical meaning defined in
The Number value for e , the base of the natural logarithms, which is approximately 2.7182818284590452354.
This property has the attributes { [[Writable]]:
The Number value for the natural logarithm of 10, which is approximately 2.302585092994046.
This property has the attributes { [[Writable]]:
The Number value for the natural logarithm of 2, which is approximately 0.6931471805599453.
This property has the attributes { [[Writable]]:
The Number value for the base-10 logarithm of e , the base of the natural logarithms; this value is approximately 0.4342944819032518.
This property has the attributes { [[Writable]]:
The value of
Math.LOG10E
is approximately the reciprocal of the value of
Math.LN10
.
The Number value for the base-2 logarithm of e , the base of the natural logarithms; this value is approximately 1.4426950408889634.
This property has the attributes { [[Writable]]:
The value of
Math.LOG2E
is approximately the reciprocal of the value of
Math.LN2
.
The Number value for π, the ratio of the circumference of a circle to its diameter, which is approximately 3.1415926535897932.
This property has the attributes { [[Writable]]:
The Number value for the square root of ½, which is approximately 0.7071067811865476.
This property has the attributes { [[Writable]]:
The value of
Math.SQRT1_2
is approximately the reciprocal of the value of
Math.SQRT2
.
The Number value for the square root of 2, which is approximately 1.4142135623730951.
This property has the attributes { [[Writable]]:
The initial value of the @@toStringTag property is the String value
"Math"
.
This property has the attributes { [[Writable]]:
Each of the following
Math
object functions applies the
In the function descriptions below, the symbols
The behaviour of the functions
acos
,
acosh
,
asin
,
asinh
,
atan
,
atanh
,
atan2
,
cbrt
,
cos
,
cosh
,
exp
,
expm1
,
hypot
,
log
,
log1p
,
log2
,
log10
,
pow
,
random
,
sin
,
sinh
,
sqrt
,
tan
, and
tanh
is not precisely specified here except to require specific results for
certain argument values that represent boundary cases of interest. For
other argument values, these functions are intended to compute
approximations to the results of familiar mathematical functions, but
some latitude is allowed in the choice of approximation algorithms. The
general intent is that an implementer should be able to use the same
mathematical library for ECMAScript on a given hardware platform that is
available to C programmers on that platform.
Although the choice of algorithms is left to the
implementation, it is recommended (but not specified by this standard)
that implementations use the approximation algorithms for IEEE 754-2008
arithmetic contained in
fdlibm
, the freely distributable mathematical library from Sun Microsystems (
http://www.netlib.org/fdlibm
).
Returns the absolute value of x ; the result has the same magnitude as x but has positive sign.
Returns an implementation-dependent approximation to the arc cosine of
x
. The result is expressed in radians and ranges from
Returns an implementation-dependent approximation to the inverse hyperbolic cosine of x .
Returns an implementation-dependent approximation to the arc sine of x . The result is expressed in radians and ranges from -π / 2 to +π / 2.
Returns an implementation-dependent approximation to the inverse hyperbolic sine of x .
Returns an implementation-dependent approximation to the arc tangent of x . The result is expressed in radians and ranges from -π / 2 to +π / 2.
Returns an implementation-dependent approximation to the inverse hyperbolic tangent of x .
Returns an implementation-dependent approximation to the arc tangent of the quotient
Returns an implementation-dependent approximation to the cube root of x .
Returns the smallest (closest to
The value of
Math.ceil(x)
is the same as the value of
-Math.floor(-x)
.
When
Math.clz32
is called with one argument
x
, the following steps are taken:
If n is 0, p will be 32. If the most significant bit of the 32-bit binary encoding of n is 1, p will be 0.
Returns an implementation-dependent approximation to the cosine of x . The argument is expressed in radians.
Returns an implementation-dependent approximation to the hyperbolic cosine of x .
The value of cosh(x) is the same as (exp(x) + exp(-x)) / 2 .
Returns an implementation-dependent approximation to the exponential function of x ( e raised to the power of x , where e is the base of the natural logarithms).
Returns an implementation-dependent approximation to subtracting 1 from the exponential function of x ( e raised to the power of x , where e is the base of the natural logarithms). The result is computed in a way that is accurate even when the value of x is close 0.
Returns the greatest (closest to
The value of
Math.floor(x)
is the same as the value of
-Math.ceil(-x)
.
When
Math.fround
is called with argument
x
, the following steps are taken:
Math.hypot
returns an implementation-dependent approximation of the square root of the sum of squares of its arguments.
Implementations should take care to avoid the loss of precision from overflows and underflows that are prone to occur in naive implementations when this function is called with two or more arguments.
When
Math.imul
is called with arguments
x
and
y
, the following steps are taken:
Returns an implementation-dependent approximation to the natural logarithm of x .
Returns an implementation-dependent approximation to the natural logarithm of 1 + x . The result is computed in a way that is accurate even when the value of x is close to zero.
Returns an implementation-dependent approximation to the base 10 logarithm of x .
Returns an implementation-dependent approximation to the base 2 logarithm of x .
Given zero or more arguments, calls
Given zero or more arguments, calls
Returns a Number value with positive sign, greater than or equal to 0 but less than 1, chosen randomly or pseudo randomly with approximately uniform distribution over that range, using an implementation-dependent algorithm or strategy. This function takes no arguments.
Each
Math.random
function created for distinct realms must produce a distinct sequence of values from successive calls.
Returns the Number value that is closest to
x
and is equal to a mathematical integer. If two integer Number values are equally close to
x
, then the result is the Number value that is closer to
Math.round(3.5)
returns 4, but
Math.round(-3.5)
returns -3.
The value of
Math.round(x)
is not always the same as the value of
Math.floor(x + 0.5)
. When
x
is
Math.round(x)
returns
Math.floor(x + 0.5)
returns
Math.round(x)
may also differ from the value of
Math.floor(x + 0.5)
because of internal rounding when computing
x + 0.5
.
Returns the sign of x , indicating whether x is positive, negative, or zero.
Returns an implementation-dependent approximation to the sine of x . The argument is expressed in radians.
Returns an implementation-dependent approximation to the hyperbolic sine of x .
The value of sinh(x) is the same as (exp(x) - exp(-x)) / 2 .
Returns an implementation-dependent approximation to the square root of x .
Returns an implementation-dependent approximation to the tangent of x . The argument is expressed in radians.
Returns an implementation-dependent approximation to the hyperbolic tangent of x .
The value of tanh(x) is the same as (exp(x) - exp(-x))/(exp(x) + exp(-x)) .
Returns the integral part of the number x , removing any fractional digits. If x is already an integer, the result is x .
The following functions are
A Date object contains a Number representing an instant in time with millisecond precision. Such a Number is called a
time value
. A time value may also be
Time is measured in ECMAScript as milliseconds since midnight
at the beginning of 01 January, 1970 UTC. Time in ECMAScript does not
observe leap seconds; they are ignored. Time calculations assume each
and every day contains exactly
A Number can exactly represent all integers from -9,007,199,254,740,992 to 9,007,199,254,740,992 (
The exact moment of midnight at the beginning of 01 January, 1970 UTC is represented by the time value
The 400 year cycle of the Gregorian calendar contains 97 leap years. This yields an average of 365.2425 days per year, or an average of 31,556,952,000 milliseconds per year under the Gregorian calendar. ECMAScript applies a proleptic Gregorian calendar for all time computations.
As specified by this section, the maximum year range a Number can represent exactly with millisecond precision is approximately -285,426 to 285,426 years relative to midnight at the beginning of 01 January, 1970 UTC.
As specified by this section, the maximum year range a time value can represent is approximately -273,790 to 273,790 years relative to midnight at the beginning of 01 January, 1970 UTC.
A given
where the number of milliseconds per day is
The remainder is called the time within the day:
ECMAScript uses a proleptic Gregorian calendar to map a day number to a year number and to determine the month and date within that year. In this calendar, leap years are precisely those which are (divisible by 4) and ((not divisible by 100) or (divisible by 400)). The number of days in year number y is therefore defined by
All non-leap years have 365 days with the usual number of days per month and leap years have an extra day in February. The day number of the first day of year y is given by:
The
A
The leap-year function is 1 for a time within a leap year and otherwise is zero:
Months are identified by an integer in the range 0 to 11, inclusive. The mapping
where
A month value of 0 specifies January; 1 specifies February; 2
specifies March; 3 specifies April; 4 specifies May; 5 specifies June; 6
specifies July; 7 specifies August; 8 specifies September; 9 specifies
October; 10 specifies November; and 11 specifies December. Note that
A date number is identified by an integer in the range 1 through 31, inclusive. The mapping DateFromTime(
t
) from a
The weekday for a particular
A weekday value of 0 specifies Sunday; 1 specifies Monday; 2
specifies Tuesday; 3 specifies Wednesday; 4 specifies Thursday; 5
specifies Friday; and 6 specifies Saturday. Note that
LocalTZA( t , isUTC ) is an implementation-defined algorithm that must return a number representing milliseconds suitable for adding to a Time Value. The local political rules for standard time and daylight saving time in effect at t should be used to determine the result in the way specified in the following three paragraphs.
When
isUTC
is true,
LocalTZA(
t
, true )
should return the offset of the local time zone from UTC measured in milliseconds at time represented by
When
isUTC
is false,
LocalTZA(
t
, false )
should return the offset of the local time zone from UTC measured in milliseconds at local time represented by
When
If an implementation does not support a conversion described above or if political rules for time t are not available within the implementation, the result must be 0.
It is recommended that implementations use the time zone information of the IANA Time Zone Database https://www.iana.org/time-zones/ .
1:30 AM on November 5, 2017 in America/New_York is repeated
twice (fall backward), but it must be interpreted as 1:30 AM UTC-04
instead of 1:30 AM UTC-05. LocalTZA(
2:30 AM on March 12, 2017 in America/New_York does not
exist, but it must be interpreted as 2:30 AM UTC-05 (equivalent to 3:30
AM UTC-04). LocalTZA(
The abstract operation LocalTime with argument t converts t from UTC to local time by performing the following steps:
Two different time values (
t
(UTC)) are converted to the same local time
The abstract operation UTC with argument t converts t from local time to UTC. It performs the following steps:
The following
where
The abstract operation MakeTime calculates a number of milliseconds from its four arguments, which must be ECMAScript Number values. This operator functions as follows:
*
+
m
*
+
s
*
+
milli
, performing the arithmetic according to IEEE 754-2008 rules (that is, as if using the ECMAScript operators
*
and
+
).
The abstract operation MakeDay calculates a number of days from its three arguments, which must be ECMAScript Number values. This operator functions as follows:
The abstract operation MakeDate calculates a number of milliseconds from its two arguments, which must be ECMAScript Number values. This operator functions as follows:
The abstract operation TimeClip calculates a number of milliseconds from its argument, which must be an ECMAScript Number value. This operator functions as follows:
The point of step 4 is that an implementation is permitted a
choice of internal representations of time values, for example as a
64-bit signed integer or as a 64-bit floating-point value. Depending on
the implementation, this internal representation may or may not
distinguish
ECMAScript defines a string interchange format for date-times
based upon a simplification of the ISO 8601 calendar date extended
format. The format is as follows:
YYYY-MM-DDTHH:mm:ss.sssZ
Where the fields are as follows:
YYYY
|
is the decimal digits of the year 0000 to 9999 in the proleptic Gregorian calendar. |
-
|
"-"
(hyphen) appears literally twice in the string.
|
MM
|
is the month of the year from 01 (January) to 12 (December). |
DD
|
is the day of the month from 01 to 31. |
T
|
"T"
appears literally in the string, to indicate the beginning of the time element.
|
HH
|
is the number of complete hours that have passed since midnight as two decimal digits from 00 to 24. |
:
|
":"
(colon) appears literally twice in the string.
|
mm
|
is the number of complete minutes since the start of the hour as two decimal digits from 00 to 59. |
ss
|
is the number of complete seconds since the start of the minute as two decimal digits from 00 to 59. |
.
|
"."
(dot) appears literally in the string.
|
sss
|
is the number of complete milliseconds since the start of the second as three decimal digits. |
Z
|
is the time zone offset specified as
"Z"
(for UTC) or either
"+"
or
"-"
followed by a time expression
HH:mm
|
This format includes date-only forms:
YYYY
YYYY-MM
YYYY-MM-DD
It also includes “date-time” forms that consist of one of the above date-only forms immediately followed by one of the following time forms with an optional time zone offset appended:
THH:mm
THH:mm:ss
THH:mm:ss.sss
All numbers must be base 10. If the
MM
or
DD
fields are absent
"01"
is used as the value. If the
HH
,
mm
, or
ss
fields are absent
"00"
is used as the value and the value of an absent
sss
field is
"000"
.
When the time zone offset is absent, date-only forms are interpreted as
a UTC time and date-time forms are interpreted as a local time.
A string containing out-of-bounds or nonconforming fields is not a valid instance of this format.
As every day both starts and ends with midnight, the two notations
00:00
and
24:00
are available to distinguish the two midnights that can be associated
with one date. This means that the following two notations refer to
exactly the same point in time:
1995-02-04T24:00
and
1995-02-05T00:00
.
This interpretation of the latter form as "end of a calendar day" is
consistent with ISO 8601, even though that specification reserves it for
describing time intervals and does not permit it within representations
of single points in time.
There exists no international standard that specifies abbreviations for civil time zones like CET, EST, etc. and sometimes the same abbreviation is even used for two very different time zones. For this reason, both ISO 8601 and this format specify numeric representations of time zone offsets.
Date.parse
Examples of date-time values with expanded years:
| -271821-04-20T00:00:00Z | 271822 B.C. |
| -000001-01-01T00:00:00Z | 2 B.C. |
| +000000-01-01T00:00:00Z | 1 B.C. |
| +000001-01-01T00:00:00Z | 1 A.D. |
| +001970-01-01T00:00:00Z | 1970 A.D. |
| +002009-12-15T00:00:00Z | 2009 A.D. |
| +275760-09-13T00:00:00Z | 275760 A.D. |
The Date
Date
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
Date
behaviour must include a
super
call to the
Date
"length"
property whose value is 7.
This description applies only if the Date
When the
Date
function is called, the following steps are taken:
"%DatePrototype%"
, « [[DateValue]] »).
This description applies only if the Date
When the
Date
function is called, the following steps are taken:
parse
method (
"%DatePrototype%"
, « [[DateValue]] »).
This description applies only if the Date
When the
Date
function is called, the following steps are taken:
"%DatePrototype%"
, « [[DateValue]] »).
The Date
The
now
function returns a Number value that is the
now
.
The
parse
function applies the
parse
interprets the resulting String as a date and time; it returns a Number, the UTC
Date.parse
to return
If
x
is any Date object whose milliseconds
amount is zero within a particular implementation of ECMAScript, then
all of the following expressions should produce the same numeric value
in that implementation, if all the properties referenced have their
initial values:
x.valueOf()
Date
.parse(x.toString())
Date
.parse(x.toUTCString())
Date
.parse(x.toISOString())
However, the expression
Date
.parse(x.toLocaleString())
is not required to produce the same Number value as the preceding three expressions and, in general, the value produced by
Date.parse
is implementation-dependent when given any String value that does not conform to the Date Time String Format (
toString
or
toUTCString
method.
The initial value of
Date.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
When the
UTC
function is called, the following steps are taken:
The
"length"
property of the
UTC
function is 7.
The
UTC
function differs from the
Date
The Date prototype object:
Unless explicitly defined otherwise, the methods of the Date prototype object defined below are not generic and the
The abstract operation thisTimeValue ( value ) performs the following steps:
In following descriptions of functions that are properties of the Date prototype object, the phrase “
this Date object
” refers to the object that is the
The initial value of
Date.prototype.constructor
is the intrinsic object
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The following steps are performed:
The
"length"
property of the
setFullYear
method is 3.
If
month
is not present, this method behaves as if
month
was present with the value
getMonth()
. If
date
is not present, it behaves as if
date
was present with the value
getDate()
.
The following steps are performed:
The
"length"
property of the
setHours
method is 4.
If
min
is not present, this method behaves as if
min
was present with the value
getMinutes()
. If
sec
is not present, it behaves as if
sec
was present with the value
getSeconds()
. If
ms
is not present, it behaves as if
ms
was present with the value
getMilliseconds()
.
The following steps are performed:
The following steps are performed:
The
"length"
property of the
setMinutes
method is 3.
If
sec
is not present, this method behaves as if
sec
was present with the value
getSeconds()
. If
ms
is not present, this behaves as if
ms
was present with the value
getMilliseconds()
.
The following steps are performed:
The
"length"
property of the
setMonth
method is 2.
If
date
is not present, this method behaves as if
date
was present with the value
getDate()
.
The following steps are performed:
The
"length"
property of the
setSeconds
method is 2.
If
ms
is not present, this method behaves as if
ms
was present with the value
getMilliseconds()
.
The following steps are performed:
The following steps are performed:
The following steps are performed:
The
"length"
property of the
setUTCFullYear
method is 3.
If
month
is not present, this method behaves as if
month
was present with the value
getUTCMonth()
. If
date
is not present, it behaves as if
date
was present with the value
getUTCDate()
.
The following steps are performed:
The
"length"
property of the
setUTCHours
method is 4.
If
min
is not present, this method behaves as if
min
was present with the value
getUTCMinutes()
. If
sec
is not present, it behaves as if
sec
was present with the value
getUTCSeconds()
. If
ms
is not present, it behaves as if
ms
was present with the value
getUTCMilliseconds()
.
The following steps are performed:
The following steps are performed:
The
"length"
property of the
setUTCMinutes
method is 3.
If
sec
is not present, this method behaves as if
sec
was present with the value
getUTCSeconds()
. If
ms
is not present, it function behaves as if
ms
was present with the value return by
getUTCMilliseconds()
.
The following steps are performed:
The
"length"
property of the
setUTCMonth
method is 2.
If
date
is not present, this method behaves as if
date
was present with the value
getUTCDate()
.
The following steps are performed:
The
"length"
property of the
setUTCSeconds
method is 2.
If
ms
is not present, this method behaves as if
ms
was present with the value
getUTCMilliseconds()
.
The following steps are performed:
"Invalid Date"
.
This function returns a String value representing the instance in time corresponding to
This function provides a String representation of a Date object for use by
JSON.stringify
(
When the
toJSON
method is called with argument
key
, the following steps are taken:
"toISOString"
).
The argument is ignored.
The
toJSON
function is intentionally generic; it does not require that its
toISOString
method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the
Date.prototype.toLocaleDateString
method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following
specification of the
toLocaleDateString
method is used.
This function returns a String value. The contents of the String are implementation-dependent, but are intended to represent the “date” portion of the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the
Date.prototype.toLocaleString
method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following
specification of the
toLocaleString
method is used.
This function returns a String value. The contents of the String are implementation-dependent, but are intended to represent the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the
Date.prototype.toLocaleTimeString
method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following
specification of the
toLocaleTimeString
method is used.
This function returns a String value. The contents of the String are implementation-dependent, but are intended to represent the “time” portion of the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
The following steps are performed:
For any Date object
d
whose milliseconds amount is zero, the result of
Date.parse(d.toString())
is equal to
d.valueOf()
. See
The
toString
function is not generic; it throws a
The following steps are performed:
":"
,
minute
,
":"
,
second
, the code unit 0x0020 (SPACE), and
"GMT"
.
The following steps are performed:
| Number | Name |
|---|---|
| 0 |
"Sun"
|
| 1 |
"Mon"
|
| 2 |
"Tue"
|
| 3 |
"Wed"
|
| 4 |
"Thu"
|
| 5 |
"Fri"
|
| 6 |
"Sat"
|
| Number | Name |
|---|---|
| 0 |
"Jan"
|
| 1 |
"Feb"
|
| 2 |
"Mar"
|
| 3 |
"Apr"
|
| 4 |
"May"
|
| 5 |
"Jun"
|
| 6 |
"Jul"
|
| 7 |
"Aug"
|
| 8 |
"Sep"
|
| 9 |
"Oct"
|
| 10 |
"Nov"
|
| 11 |
"Dec"
|
The following steps are performed:
"+"
; otherwise, let
offsetSign
be
"-"
.
The following steps are performed:
"Invalid Date"
.
The following steps are performed:
"Invalid Date"
.
The following steps are performed:
"Invalid Date"
.
","
, the code unit 0x0020 (SPACE),
day
, the code unit 0x0020 (SPACE),
month
, the code unit 0x0020 (SPACE),
year
, the code unit 0x0020 (SPACE), and
The following steps are performed:
This function is called by ECMAScript language operators to convert a Date object to a primitive value. The allowed values for
hint
are
"default"
,
"number"
, and
"string"
. Date objects, are unique among built-in ECMAScript object in that they treat
"default"
as being equivalent to
"string"
, All other built-in ECMAScript objects treat
"default"
as being equivalent to
"number"
.
When the
@@toPrimitive
method is called with argument
hint
, the following steps are taken:
"string"
or the String value
"default"
, then
"string"
.
"number"
, then
"number"
.
The value of the
name
property of this function is
"[Symbol.toPrimitive]"
.
This property has the attributes { [[Writable]]:
Date instances are ordinary objects that inherit properties
from the Date prototype object. Date instances also have a [[DateValue]]
internal slot. The [[DateValue]] internal slot is the
The String
String
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
String
behaviour must include a
super
call to the
String
When
String
is called with argument
value
, the following steps are taken:
""
.
"%StringPrototype%"
)).
The String
The
String.fromCharCode
function may be called with any number of arguments which form the rest parameter
codeUnits
. The following steps are taken:
The
"length"
property of the
fromCharCode
function is 1.
The
String.fromCodePoint
function may be called with any number of arguments which form the rest parameter
codePoints
. The following steps are taken:
The
"length"
property of the
fromCodePoint
function is 1.
The initial value of
String.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The
String.raw
function may be called with a variable number of arguments. The first argument is
template
and the remainder of the arguments form the
"raw"
)).
"length"
)).
String.raw is intended for use as a tag function of a Tagged Template (
The String prototype object:
"length"
property whose initial value is 0 and whose attributes are { [[Writable]]:
Unless explicitly stated otherwise, the methods of the String prototype object defined below are not generic and the
The abstract operation thisStringValue ( value ) performs the following steps:
Returns a single element String containing the code unit at index pos within the String value resulting from converting this object to a String. If there is no element at that index, the result is the empty String. The result is a String value, not a String object.
If
pos
is a value of Number type that is an integer, then the result of
x.charAt(pos)
is equal to the result of
x.substring(pos, pos + 1)
.
When the
charAt
method is called with one argument
pos
, the following steps are taken:
The
charAt
function is intentionally generic; it does not require that its
Returns a Number (a nonnegative integer less than 2
16
) that is the numeric value of the code unit at index
pos
within the String resulting from converting this object to a String. If there is no element at that index, the result is
When the
charCodeAt
method is called with one argument
pos
, the following steps are taken:
The
charCodeAt
function is intentionally generic; it does not require that its
Returns a nonnegative integer Number less than 0x110000 that is the code point value of the UTF-16 encoded code point (
When the
codePointAt
method is called with one argument
pos
, the following steps are taken:
The
codePointAt
function is intentionally generic; it does not require that its
When the
concat
method is called it returns the String value consisting of the code units of the
this
object (converted to a String) followed by the code units of each of
the arguments converted to a String. The result is a String value, not a
String object.
When the
concat
method is called with zero or more arguments, the following steps are taken:
The
"length"
property of the
concat
method is 1.
The
concat
function is intentionally generic; it does not require that its
The initial value of
String.prototype.constructor
is the intrinsic object
The following steps are taken:
Returns
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
The
endsWith
function is intentionally generic; it does not require that its
The
includes
method takes two arguments,
searchString
and
position
, and performs the following steps:
If
searchString
appears as a substring of the
result of converting this object to a String, at one or more indices
that are greater than or equal to
position
, return
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
The
includes
function is intentionally generic; it does not require that its
If
searchString
appears as a substring of the
result of converting this object to a String, at one or more indices
that are greater than or equal to
position
, then the smallest such index is returned; otherwise, -1 is returned. If
position
is
The
indexOf
method takes two arguments,
searchString
and
position
, and performs the following steps:
The
indexOf
function is intentionally generic; it does not require that its
If
searchString
appears as a substring of the
result of converting this object to a String at one or more indices that
are smaller than or equal to
position
, then the greatest such index is returned; otherwise, -1 is returned. If
position
is
The
lastIndexOf
method takes two arguments,
searchString
and
position
, and performs the following steps:
The
lastIndexOf
function is intentionally generic; it does not require that its
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the
localeCompare
method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following
specification of the
localeCompare
method is used.
When the
localeCompare
method is called with argument
that
, it returns a Number other than
Before performing the comparisons, the following steps are performed to prepare the Strings:
The meaning of the optional second and third parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not assign any other interpretation to those parameter positions.
The
localeCompare
method, if considered as a function of two arguments
The actual return values are implementation-defined to permit
implementers to encode additional information in the value, but the
function is required to define a total ordering on all Strings. This
function must treat Strings that are canonically equivalent according to
the Unicode standard as identical and must return
0
when comparing Strings that are considered canonically equivalent.
The
localeCompare
method itself is not directly suitable as an argument to
Array.prototype.sort
because the latter requires a function of two arguments.
This function is intended to rely on whatever language-sensitive comparison functionality is available to the ECMAScript environment from the host environment, and to compare according to the rules of the host environment's current locale. However, regardless of the host provided comparison capabilities, this function must treat Strings that are canonically equivalent according to the Unicode standard as identical. It is recommended that this function should not honour Unicode compatibility equivalences or decompositions. For a definition and discussion of canonical equivalence see the Unicode Standard, chapters 2 and 3, as well as Unicode Standard Annex #15, Unicode Normalization Forms ( https://unicode.org/reports/tr15/ ) and Unicode Technical Note #5, Canonical Equivalence in Applications ( https://www.unicode.org/notes/tn5/ ). Also see Unicode Technical Standard #10, Unicode Collation Algorithm ( https://unicode.org/reports/tr10/ ).
The
localeCompare
function is intentionally generic; it does not require that its
When the
match
method is called with argument
regexp
, the following steps are taken:
The
match
function is intentionally generic; it does not require that its
When the
normalize
method is called with one argument
form
, the following steps are taken:
"NFC"
.
"NFC"
,
"NFD"
,
"NFKC"
, or
"NFKD"
, throw a
The
normalize
function is intentionally generic; it does not require that its
When the
padEnd
method is called, the following steps are taken:
The first argument
maxLength
will be clamped such that it can be no smaller than the length of the
The optional second argument
fillString
defaults to
When the
padStart
method is called, the following steps are taken:
The first argument
maxLength
will be clamped such that it can be no smaller than the length of the
The optional second argument
fillString
defaults to
The following steps are taken:
This method creates the String value consisting of the code units of the
this
object (converted to String) repeated
count
times.
The
repeat
function is intentionally generic; it does not require that its
When the
replace
method is called with arguments
searchValue
and
replaceValue
, the following steps are taken:
The
replace
function is intentionally generic; it does not require that its
The abstract operation GetSubstitution performs the following steps:
$
replacements are done left-to-right, and, once such a replacement is
performed, the new replacement text is not subject to further
replacements.
| Code units | Unicode Characters | Replacement text |
|---|---|---|
| 0x0024, 0x0024 |
$$
|
$
|
| 0x0024, 0x0026 |
$&
|
matched |
| 0x0024, 0x0060 |
$`
|
If position is 0, the replacement is the empty String. Otherwise the replacement is the substring of str that starts at index 0 and whose last code unit is at index position - 1. |
| 0x0024, 0x0027 |
$'
|
If tailPos ≥ stringLength , the replacement is the empty String. Otherwise the replacement is the substring of str that starts at index tailPos and continues to the end of str . |
|
0x0024, N
Where 0x0031 ≤ N ≤ 0x0039 |
$n
where
n
is one of
1 2 3 4 5 6 7 8 9
and
$n
is not followed by a decimal digit
|
The
n
th
element of
captures
, where
n
is a single digit in the range 1 to 9. If
n
≤
m
and the
n
th
element of
captures
is
|
|
0x0024, N, N
Where 0x0030 ≤ N ≤ 0x0039 |
$nn
where
n
is one of
0 1 2 3 4 5 6 7 8 9
|
The
nn
th
element of
captures
, where
nn
is a two-digit decimal number in the range 01 to 99. If
nn
≤
m
and the
nn
th
element of
captures
is
|
| 0x0024, 0x003C |
$<
|
|
| 0x0024 |
$
in any context that does not match any of the above.
|
$
|
When the
search
method is called with argument
regexp
, the following steps are taken:
The
search
function is intentionally generic; it does not require that its
The
slice
method takes two arguments,
start
and
end
, and returns a substring of the result of converting this object to a String, starting from index
start
and running to, but not including, index
end
(or through the end of the String if
end
is
The
slice
function is intentionally generic; it does not require that its
Returns an Array object into which substrings of the result of converting this object to a String have been stored. The substrings are determined by searching from left to right for occurrences of separator ; these occurrences are not part of any substring in the returned array, but serve to divide up the String value. The value of separator may be a String of any length or it may be an object, such as a RegExp, that has a @@split method.
When the
split
method is called, the following steps are taken:
"0"
,
S
).
"0"
,
S
).
The value of separator may be an empty String. In this case, separator does not match the empty substring at the beginning or end of the input String, nor does it match the empty substring at the end of the previous separator match. If separator is the empty String, the String is split up into individual code unit elements; the length of the result array equals the length of the String, and each substring contains one code unit.
If the
If
separator
is
The
split
function is intentionally generic; it does not require that its
The abstract operation SplitMatch takes three parameters, a String
S
, an integer
q
, and a String
R
, and performs the following steps in order to return either
The following steps are taken:
This method returns
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
The
startsWith
function is intentionally generic; it does not require that its
The
substring
method takes two arguments,
start
and
end
, and returns a substring of the result of converting this object to a String, starting from index
start
and running to, but not including, index
end
of the String (or through the end of the String if
end
is
If either argument is
If start is larger than end , they are swapped.
The following steps are taken:
The
substring
function is intentionally generic; it does not require that its
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the
toLocaleLowerCase
method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following
specification of the
toLocaleLowerCase
method is used.
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
This function works exactly the same as
toLowerCase
except that its result is intended to yield the correct result for the
host environment's current locale, rather than a locale-independent
result. There will only be a difference in the few cases (such as
Turkish) where the rules for that language conflict with the regular
Unicode case mappings.
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
The
toLocaleLowerCase
function is intentionally generic; it does not require that its
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the
toLocaleUpperCase
method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following
specification of the
toLocaleUpperCase
method is used.
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
This function works exactly the same as
toUpperCase
except that its result is intended to yield the correct result for the
host environment's current locale, rather than a locale-independent
result. There will only be a difference in the few cases (such as
Turkish) where the rules for that language conflict with the regular
Unicode case mappings.
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
The
toLocaleUpperCase
function is intentionally generic; it does not require that its
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
The result must be derived according to the locale-insensitive case mappings in the Unicode Character Database (this explicitly includes not only the UnicodeData.txt file, but also all locale-insensitive mappings in the SpecialCasings.txt file that accompanies it).
The case mapping of some code points may produce multiple
code points. In this case the result String may not be the same length
as the source String. Because both
toUpperCase
and
toLowerCase
have context-sensitive behaviour, the functions are not symmetrical. In other words,
s.toUpperCase().toLowerCase()
is not necessarily equal to
s.toLowerCase()
.
The
toLowerCase
function is intentionally generic; it does not require that its
When the
toString
method is called, the following steps are taken:
For a String object, the
toString
method happens to return the same thing as the
valueOf
method.
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
This function behaves in exactly the same way as
String.prototype.toLowerCase
, except that the String is mapped using the toUppercase algorithm of the Unicode Default Case Conversion.
The
toUpperCase
function is intentionally generic; it does not require that its
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
The following steps are taken:
"start+end"
).
The
trim
function is intentionally generic; it does not require that its
The abstract operation TrimString is called with arguments
string
and
where
, and interprets the String value
string
as a sequence of UTF-16 encoded code points, as described in
"start"
, let
T
be the String value that is a copy of
S
with leading white space removed.
"end"
, let
T
be the String value that is a copy of
S
with trailing white space removed.
"start+end"
.
The definition of white space is the union of
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
The following steps are taken:
"end"
).
The
trimEnd
function is intentionally generic; it does not require that its
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
The following steps are taken:
"start"
).
The
trimStart
function is intentionally generic; it does not require that its
When the
valueOf
method is called, the following steps are taken:
When the
@@iterator
method is called it returns an Iterator object (
The value of the
name
property of this function is
"[Symbol.iterator]"
.
String instances are String exotic objects and have the internal methods specified for such objects. String instances inherit properties from the String prototype object. String instances also have a [[StringData]] internal slot.
String instances have a
"length"
property, and a set of enumerable properties with integer-indexed names.
The number of elements in the String value represented by this String object.
Once a String object is initialized, this property is unchanging. It has the attributes { [[Writable]]:
A String Iterator is an object, that represents a specific
iteration over some specific String instance object. There is not a
named
Several methods of String objects return Iterator objects. The abstract operation CreateStringIterator with argument string is used to create such iterator objects. It performs the following steps:
The %StringIteratorPrototype% object:
The initial value of the @@toStringTag property is the String value
"String Iterator"
.
This property has the attributes { [[Writable]]:
String Iterator instances are ordinary objects that inherit properties from the
| Internal Slot | Description |
|---|---|
| [[IteratedString]] | The String value whose code units are being iterated. |
| [[StringIteratorNextIndex]] |
The
|
A RegExp object contains a regular expression and the associated flags.
The form and functionality of regular expressions is modelled after the regular expression facility in the Perl 5 programming language.
The
RegExp
Each
\u
u
u
\u
"$"
, or
"_"
, or the
"$"
, or
"_"
, or the
The definitions of “the MV of
| ControlEscape | Code Point Value | Code Point | Unicode Name | Symbol |
|---|---|---|---|---|
t
|
9 |
U+0009
|
CHARACTER TABULATION |
|
n
|
10 |
U+000A
|
LINE FEED (LF) |
|
v
|
11 |
U+000B
|
LINE TABULATION |
|
f
|
12 |
U+000C
|
FORM FEED (FF) |
|
r
|
13 |
U+000D
|
CARRIAGE RETURN (CR) |
|
\0
represents the
\
A regular expression pattern is converted into an internal procedure using the process described below. An implementation is encouraged to use more efficient algorithms than the ones listed below, as long as the results are the same. The internal procedure is used as the value of a RegExp object's [[RegExpMatcher]] internal slot.
A
"u"
.
A BMP pattern matches against a String interpreted as consisting of a
sequence of 16-bit values that are Unicode code points in the range of
the Basic Multilingual Plane. A Unicode pattern matches against a String
interpreted as consisting of Unicode code points encoded using UTF-16.
In the context of describing the behaviour of a BMP pattern “character”
means a single 16-bit Unicode BMP code point. In the context of
describing the behaviour of a Unicode pattern “character” means a UTF-16
encoded code point (
The syntax and semantics of
For example, consider a pattern expressed in source text as
the single non-BMP character U+1D11E (MUSICAL SYMBOL G CLEF).
Interpreted as a Unicode pattern, it would be a single element
(character)
Patterns are passed to the RegExp
An implementation may not actually perform such translations to or from UTF-16, but the semantics of this specification requires that the result of pattern matching be as if such translations were performed.
The descriptions below use the following variables:
(
pattern character that is matched by the
(
terminal of the
"s"
and otherwise is
"i"
and otherwise is
"m"
and otherwise is
"u"
and otherwise is
Furthermore, the descriptions below use the following internal data structures:
The production
A Pattern evaluates (“compiles”) to an internal procedure value.
With parameter direction .
The production
The production
The
|
regular expression operator separates two alternatives. The pattern first tries to match the left
|
produce
/a|ab/.exec(
"abc"
)
returns the result
"a"
and not
"ab"
. Moreover,
/((a)|(ab))((c)|(bc))/.exec(
"abc"
)
returns the array
[
"abc"
,
"a"
,
"a"
,
undefined
,
"bc"
,
undefined
,
"bc"
]
and not
[
"abc"
,
"ab"
,
undefined
,
"ab"
,
"c"
,
"c"
,
undefined
]
The order in which the two alternatives are tried is independent of the value of direction .
With parameter direction .
The production
The production
Consecutive
With parameter direction .
The production
The AssertionTester is independent of direction .
The production
The production
The abstract operation RepeatMatcher takes eight parameters, a Matcher m , an integer min , an integer (or ∞) max , a Boolean greedy , a State x , a Continuation c , an integer parenIndex , and an integer parenCount , and performs the following steps:
An
If the
Compare
/a[a-z]{
2
,
4
}/.exec(
"abcdefghi"
)
which returns
"abcde"
with
/a[a-z]{
2
,
4
}?
/.exec("abcdefghi")
which returns
"abc"
.
Consider also
/(aa|aabaac|ba|b|c)*
/.exec("aabaac")
which, by the choice point ordering above, returns the array
[
"aaba"
,
"ba"
]
and not any of:
[
"aabaac"
,
"aabaac"
]
[
"aabaac"
,
"c"
]
The above ordering of choice points can be used to write a regular expression that calculates the greatest common divisor of two numbers (represented in unary notation). The following example calculates the gcd of 10 and 15:
"aaaaaaaaaa,aaaaaaaaaaaaaaa"
.replace(
/^(a+)\1*,\1+$/
,
"$1"
)
which returns the gcd in unary notation
"aaaaa"
.
Step 4 of the RepeatMatcher clears
/(z)((a+)?(b+)?(c))*
/.exec("zaacbbbcac")
which returns the array
[
"zaacbbbcac"
,
"z"
,
"ac"
,
"a"
,
undefined
,
"c"
]
and not
[
"zaacbbbcac"
,
"z"
,
"ac"
,
"a"
,
"bbb"
,
"c"
]
because each iteration of the outermost
*
clears all captured Strings contained in the quantified
Step 1 of the RepeatMatcher's
d
closure states that, once the minimum number of repetitions has been satisfied, any more expansions of
/(a*)*
/.exec("b")
or the slightly more complicated:
/(a*)b\
1
+
/.exec("baaaac")
which returns the array
[
"b"
,
""
]
The production
Even when the
y
flag is used with a pattern,
^
always matches only at the beginning of
Input
, or (if
Multiline
is
The production
The production
The production
The production
The production
The production
The production
The abstract operation WordCharacters performs the following steps:
a
|
b
|
c
|
d
|
e
|
f
|
g
|
h
|
i
|
j
|
k
|
l
|
m
|
n
|
o
|
p
|
q
|
r
|
s
|
t
|
u
|
v
|
w
|
x
|
y
|
z
|
A
|
B
|
C
|
D
|
E
|
F
|
G
|
H
|
I
|
J
|
K
|
L
|
M
|
N
|
O
|
P
|
Q
|
R
|
S
|
T
|
U
|
V
|
W
|
X
|
Y
|
Z
|
0
|
1
|
2
|
3
|
4
|
5
|
6
|
7
|
8
|
9
|
_
|
The abstract operation IsWordChar takes an integer parameter e and performs the following steps:
The production
The production
The production
The production
The production
The production
The production
The production
With parameter direction .
The production
The production
The production
The production
The production
The production
The abstract operation CharacterSetMatcher takes three arguments, a CharSet A , a Boolean flag invert , and an integer direction , and performs the following steps:
The abstract operation Canonicalize takes a character parameter ch and performs the following steps:
String.prototype.toUpperCase
using
s
as the
Parentheses of the form
(
)
serve both to group the components of the
\
followed by a nonzero decimal number), referenced in a replace String,
or returned as part of an array from the regular expression matching
internal procedure. To inhibit the capturing behaviour of parentheses,
use the form
(?:
)
instead.
The form
(?=
)
specifies a zero-width positive lookahead. In order for it to succeed, the pattern inside
(?=
form (this unusual behaviour is inherited from Perl). This only matters when the
For example,
/(?=(a+))/.exec(
"baaabac"
)
matches the empty String immediately after the first
b
and therefore returns the array:
[
""
,
"aaa"
]
To illustrate the lack of backtracking into the lookahead, consider:
/(?=(a+))a*b\
1
/.exec(
"baaabac"
)
This expression returns
[
"aba"
,
"a"
]
and not:
[
"aaaba"
,
"a"
]
The form
(?!
)
specifies a zero-width negative lookahead. In order for it to succeed, the pattern inside
/(.*?)a(?!(a+)b\
2
c)\
2
(.*)/.exec(
"baaabaac"
)
looks for an
a
not immediately followed by some positive number n of
a
's, a
b
, another n
a
's (specified by the first
\2
) and a
c
. The second
\2
is outside the negative lookahead, so it matches against
[
"baaabaac"
,
"ba"
,
undefined
,
"abaac"
]
In case-insignificant matches when
Unicode
is
"ß"
(U+00DF) to
"SS"
. It may however map a code point outside the Basic Latin range to a character within, for example,
"ſ"
(U+017F) to
"s"
. Such characters are not mapped if
Unicode
is
/[a-z]/i
, but they will match
/[a-z]/ui
.
The abstract operation UnicodeMatchProperty takes a parameter
p
that is a
Implementations must support the Unicode property names and aliases listed in
For example,
Script_Extensions
(
scx
(property alias) are valid, but
script_extensions
or
Scx
aren't.
The listed properties form a superset of what UTS18 RL1.2 requires.
|
|
Canonical
|
|---|---|
|
General_Category
|
|
Script
|
|
Script_Extensions
|
|
|
Canonical
|
|---|---|
ASCII
|
ASCII
|
|
ASCII_Hex_Digit
|
|
Alphabetic
|
Any
|
Any
|
Assigned
|
Assigned
|
|
Bidi_Control
|
|
Bidi_Mirrored
|
|
Case_Ignorable
|
Cased
|
Cased
|
|
Changes_When_Casefolded
|
|
Changes_When_Casemapped
|
|
Changes_When_Lowercased
|
|
Changes_When_NFKC_Casefolded
|
|
Changes_When_Titlecased
|
|
Changes_When_Uppercased
|
Dash
|
Dash
|
|
Default_Ignorable_Code_Point
|
|
Deprecated
|
|
Diacritic
|
Emoji
|
Emoji
|
Emoji_Component
|
Emoji_Component
|
Emoji_Modifier
|
Emoji_Modifier
|
Emoji_Modifier_Base
|
Emoji_Modifier_Base
|
Emoji_Presentation
|
Emoji_Presentation
|
Extended_Pictographic
|
Extended_Pictographic
|
|
Extender
|
|
Grapheme_Base
|
|
Grapheme_Extend
|
|
Hex_Digit
|
|
IDS_Binary_Operator
|
|
IDS_Trinary_Operator
|
|
ID_Continue
|
|
ID_Start
|
|
Ideographic
|
|
Join_Control
|
|
Logical_Order_Exception
|
|
Lowercase
|
Math
|
Math
|
|
Noncharacter_Code_Point
|
|
Pattern_Syntax
|
|
Pattern_White_Space
|
|
Quotation_Mark
|
Radical
|
Radical
|
|
Regional_Indicator
|
|
Sentence_Terminal
|
|
Soft_Dotted
|
|
Terminal_Punctuation
|
|
Unified_Ideograph
|
|
Uppercase
|
|
Variation_Selector
|
|
White_Space
|
|
XID_Continue
|
|
XID_Start
|
The abstract operation UnicodeMatchPropertyValue takes two parameters
p
and
v
, each of which is a
Implementations must support the Unicode property value names and aliases listed in
For example,
Xpeo
and
Old_Persian
are valid
Script_Extensions
values, but
xpeo
and
Old Persian
aren't.
This algorithm differs from
the matching rules for symbolic values listed in UAX44
: case,
Is
prefix is not supported.
General_Category
| Property value and aliases | Canonical property value |
|---|---|
|
Cased_Letter
|
|
Close_Punctuation
|
|
Connector_Punctuation
|
|
Control
|
|
Currency_Symbol
|
|
Dash_Punctuation
|
|
Decimal_Number
|
|
Enclosing_Mark
|
|
Final_Punctuation
|
|
Format
|
|
Initial_Punctuation
|
|
Letter
|
|
Letter_Number
|
|
Line_Separator
|
|
Lowercase_Letter
|
|
Mark
|
|
Math_Symbol
|
|
Modifier_Letter
|
|
Modifier_Symbol
|
|
Nonspacing_Mark
|
|
Number
|
|
Open_Punctuation
|
|
Other
|
|
Other_Letter
|
|
Other_Number
|
|
Other_Punctuation
|
|
Other_Symbol
|
|
Paragraph_Separator
|
|
Private_Use
|
|
Punctuation
|
|
Separator
|
|
Space_Separator
|
|
Spacing_Mark
|
|
Surrogate
|
|
Symbol
|
|
Titlecase_Letter
|
|
Unassigned
|
|
Uppercase_Letter
|
Script
and
Script_Extensions
| Property value and aliases | Canonical property value |
|---|---|
|
Adlam
|
|
Ahom
|
|
Anatolian_Hieroglyphs
|
|
Arabic
|
|
Armenian
|
|
Avestan
|
|
Balinese
|
|
Bamum
|
|
Bassa_Vah
|
|
Batak
|
|
Bengali
|
|
Bhaiksuki
|
|
Bopomofo
|
|
Brahmi
|
|
Braille
|
|
Buginese
|
|
Buhid
|
|
Canadian_Aboriginal
|
|
Carian
|
|
Caucasian_Albanian
|
|
Chakma
|
|
Cham
|
|
Cherokee
|
|
Common
|
|
Coptic
|
|
Cuneiform
|
|
Cypriot
|
|
Cyrillic
|
|
Deseret
|
|
Devanagari
|
|
Dogra
|
|
Duployan
|
|
Egyptian_Hieroglyphs
|
|
Elbasan
|
|
Ethiopic
|
|
Georgian
|
|
Glagolitic
|
|
Gothic
|
|
Grantha
|
|
Greek
|
|
Gujarati
|
|
Gunjala_Gondi
|
|
Gurmukhi
|
|
Han
|
|
Hangul
|
|
Hanifi_Rohingya
|
|
Hanunoo
|
|
Hatran
|
|
Hebrew
|
|
Hiragana
|
|
Imperial_Aramaic
|
|
Inherited
|
|
Inscriptional_Pahlavi
|
|
Inscriptional_Parthian
|
|
Javanese
|
|
Kaithi
|
|
Kannada
|
|
Katakana
|
|
Kayah_Li
|
|
Kharoshthi
|
|
Khmer
|
|
Khojki
|
|
Khudawadi
|
|
Lao
|
|
Latin
|
|
Lepcha
|
|
Limbu
|
|
Linear_A
|
|
Linear_B
|
|
Lisu
|
|
Lycian
|
|
Lydian
|
|
Mahajani
|
|
Makasar
|
|
Malayalam
|
|
Mandaic
|
|
Manichaean
|
|
Marchen
|
|
Medefaidrin
|
|
Masaram_Gondi
|
|
Meetei_Mayek
|
|
Mende_Kikakui
|
|
Meroitic_Cursive
|
|
Meroitic_Hieroglyphs
|
|
Miao
|
|
Modi
|
|
Mongolian
|
|
Mro
|
|
Multani
|
|
Myanmar
|
|
Nabataean
|
|
New_Tai_Lue
|
|
Newa
|
|
Nko
|
|
Nushu
|
|
Ogham
|
|
Ol_Chiki
|
|
Old_Hungarian
|
|
Old_Italic
|
|
Old_North_Arabian
|
|
Old_Permic
|
|
Old_Persian
|
|
Old_Sogdian
|
|
Old_South_Arabian
|
|
Old_Turkic
|
|
Oriya
|
|
Osage
|
|
Osmanya
|
|
Pahawh_Hmong
|
|
Palmyrene
|
|
Pau_Cin_Hau
|
|
Phags_Pa
|
|
Phoenician
|
|
Psalter_Pahlavi
|
|
Rejang
|
|
Runic
|
|
Samaritan
|
|
Saurashtra
|
|
Sharada
|
|
Shavian
|
|
Siddham
|
|
SignWriting
|
|
Sinhala
|
|
Sogdian
|
|
Sora_Sompeng
|
|
Soyombo
|
|
Sundanese
|
|
Syloti_Nagri
|
|
Syriac
|
|
Tagalog
|
|
Tagbanwa
|
|
Tai_Le
|
|
Tai_Tham
|
|
Tai_Viet
|
|
Takri
|
|
Tamil
|
|
Tangut
|
|
Telugu
|
|
Thaana
|
|
Thai
|
|
Tibetan
|
|
Tifinagh
|
|
Tirhuta
|
|
Ugaritic
|
|
Vai
|
|
Warang_Citi
|
|
Yi
|
|
Zanabazar_Square
|
With parameter direction .
The production
The production
The production
An escape sequence of the form
\
followed by a nonzero decimal number
n
matches the result of the
n
th set of capturing parentheses (
The production
The abstract operation BackreferenceMatcher takes two arguments, an integer n and an integer direction , and performs the following steps:
The
The
If
\
is followed by a decimal number
n
whose first digit is not
0
, then the escape sequence is considered to be a backreference. It is an error if
n
is greater than the total number of left-capturing parentheses in the entire regular expression.
The production
0
through
9
inclusive.
The production
The production
The production
The production
The production
The production
The production
The production
The production
"General_Category"
,
s
) is identical to a
The production
The production
The production
The production
The production
The production
The production
The abstract operation CharacterRange takes two CharSet parameters A and B and performs the following steps:
The production
The production
The production
Even if the pattern ignores case, the case of the two ends
of a range is significant in determining which characters belong to the
range. Thus, for example, the pattern
/[E-F]/i
matches only the letters
E
,
F
,
e
, and
f
, while the pattern
/[E-f]/i
matches all upper and lower-case letters in the Unicode Basic Latin block as well as the symbols
[
,
\
,
]
,
^
,
_
, and
`
.
A
-
character can be treated literally or it can denote a range. It is treated literally if it is the first or last character of
The production
-
U+002D (HYPHEN-MINUS).
The production
The production
The production
The
A
\b
,
\B
, and backreferences. Inside a
\b
means the backspace character, while
\B
and backreferences raise errors. Using a backreference inside a
The RegExp
RegExp
property of the
RegExp(…)
is equivalent to the object creation expression
new RegExp(…)
with the same arguments.
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
RegExp
behaviour must include a
super
call to the
RegExp
The following steps are taken:
If pattern is supplied using a
When the abstract operation RegExpAlloc with argument newTarget is called, the following steps are taken:
"%RegExpPrototype%"
, « [[RegExpMatcher]], [[OriginalSource]], [[OriginalFlags]] »).
"lastIndex"
, PropertyDescriptor { [[Writable]]:
When the abstract operation RegExpInitialize with arguments obj , pattern , and flags is called, the following steps are taken:
"g"
,
"i"
,
"m"
,
"s"
,
"u"
, or
"y"
or if it contains the same code unit more than once, throw a
"u"
, let
BMP
be
"lastIndex"
, 0,
When the abstract operation RegExpCreate with arguments P and F is called, the following steps are taken:
When the abstract operation EscapeRegExpPattern with arguments P and F is called, the following occurs:
"u"
) equivalent to
P
interpreted as UTF-16 encoded Unicode code points (
"u"
)
must behave identically to the internal procedure given by the
constructed object's [[RegExpMatcher]] internal slot. Multiple calls to
this abstract operation using the same values for
P
and
F
must produce identical results.
/
or any
"/"
,
S
,
"/"
, and
F
can be parsed (in an appropriate lexical context) as a
"/"
, then
S
could be
"\/"
or
"\u002F"
, among other possibilities, but not
"/"
, because
///
followed by
F
would be parsed as a
"(?:)"
.
The RegExp
The initial value of
RegExp.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
RegExp[@@species]
is an
The value of the
name
property of this function is
"get [Symbol.species]"
.
RegExp prototype methods normally use their
this
object's
The RegExp prototype object:
The RegExp prototype object does not have a
valueOf
property of its own; however, it inherits the
valueOf
property from the Object prototype object.
The initial value of
RegExp.prototype.constructor
is the intrinsic object
Performs a regular expression match of
string
against the regular expression and returns an Array object containing the results of the match, or
The String
The abstract operation RegExpExec with arguments R and S performs the following steps:
"exec"
).
If a callable
exec
property is not found
this algorithm falls back to attempting to use the built-in RegExp
matching algorithm. This provides compatible behaviour for code written
for prior editions where most built-in algorithms that use regular
expressions did not perform a dynamic property lookup of
exec
.
The abstract operation RegExpBuiltinExec with arguments R and S performs the following steps:
"lastIndex"
)).
"g"
, let
global
be
"y"
, let
sticky
be
"u"
, let
fullUnicode
be
"lastIndex"
, 0,
"lastIndex"
, 0,
"lastIndex"
,
e
,
"length"
property is
n
+ 1.
"index"
,
lastIndex
).
"input"
,
S
).
"0"
,
matchedSubstr
).
"groups"
,
groups
).
The abstract operation AdvanceStringIndex with arguments S , index , and unicode performs the following steps:
RegExp.prototype.dotAll
is an
RegExp.prototype.flags
is an
"global"
)).
"ignoreCase"
)).
"multiline"
)).
"dotAll"
)).
"unicode"
)).
"sticky"
)).
RegExp.prototype.global
is an
RegExp.prototype.ignoreCase
is an
When the
@@match
method is called with argument
string
, the following steps are taken:
"global"
)).
"unicode"
)).
"lastIndex"
, 0,
"0"
)).
"lastIndex"
)).
"lastIndex"
,
nextIndex
,
The value of the
name
property of this function is
"[Symbol.match]"
.
The @@match property is used by the
RegExp.prototype.multiline
is an
When the
@@replace
method is called with arguments
string
and
replaceValue
, the following steps are taken:
"global"
)).
"length"
)).
"0"
)).
"index"
)).
"groups"
).
The value of the
name
property of this function is
"[Symbol.replace]"
.
When the
@@search
method is called with argument
string
, the following steps are taken:
"lastIndex"
).
"lastIndex"
, 0,
"lastIndex"
).
"lastIndex"
,
previousLastIndex
,
"index"
).
The value of the
name
property of this function is
"[Symbol.search]"
.
The
lastIndex
and
global
properties of this RegExp object are ignored when performing the search. The
lastIndex
property is left unchanged.
RegExp.prototype.source
is an
"(?:)"
.
Returns an Array object into which substrings of the result of converting
string
to a String have been stored. The substrings are determined by searching from left to right for matches of the
The
/a*?/[Symbol.split]("ab")
evaluates to the array
["a", "b"]
, while
/a*/[Symbol.split]("ab")
evaluates to the array
["","b"]
.)
If the string is (or converts to) the empty String, the result depends on whether the regular expression can match the empty String. If it can, the result array contains no elements. Otherwise, the result array contains one element, which is the empty String.
If the regular expression contains capturing parentheses, then each time
separator
is matched the results (including any
/
<
(\
/)?([^<>
]+)>/[Symbol.split]("A
<
B
>
bold
B
>
and
<
CODE
>
coded
CODE
>
")
evaluates to the array
[
"A"
,
undefined
,
"B"
,
"bold"
,
"/"
,
"B"
,
"and"
,
undefined
,
"CODE"
,
"coded"
,
"/"
,
"CODE"
,
""
]
If
limit
is not
When the
@@split
method is called, the following steps are taken:
"flags"
)).
"u"
, let
unicodeMatching
be
"y"
, let
newFlags
be
flags
.
"y"
.
"0"
,
S
).
"lastIndex"
,
q
,
"lastIndex"
)).
"length"
)).
The value of the
name
property of this function is
"[Symbol.split]"
.
The
@@split
method ignores the value of the
global
and
sticky
properties of this RegExp object.
RegExp.prototype.sticky
is an
The following steps are taken:
The returned String has the form of a
RegExp.prototype.unicode
is an
RegExp instances are ordinary objects that inherit properties
from the RegExp prototype object. RegExp instances have internal slots
[[RegExpMatcher]], [[OriginalSource]], and [[OriginalFlags]]. The value
of the [[RegExpMatcher]] internal slot is an implementation-dependent
representation of the
Prior to ECMAScript 2015,
RegExp
instances were specified as having the own data properties
source
,
global
,
ignoreCase
, and
multiline
. Those properties are now specified as accessor properties of RegExp.prototype.
RegExp instances also have the following property:
The value of the
lastIndex
property specifies the String index at which to start the next match. It is coerced to an integer when used (see
Array objects are exotic objects that give special treatment to a certain class of property names. See
The Array
Array
property of the
Array(…)
is equivalent to the object creation expression
new Array(…)
with the same arguments.
extends
clause of a class definition. Subclass constructors that intend to inherit the exotic
Array
behaviour must include a
super
call to the
Array
Array.prototype
methods are generic methods that are not dependent upon their
this
value being an Array
"length"
property whose value is 1.
This description applies if and only if the Array
"%ArrayPrototype%"
).
This description applies if and only if the Array
"%ArrayPrototype%"
).
"0"
,
len
).
"length"
,
intLen
,
This description applies if and only if the Array
When the
Array
function is called, the following steps are taken:
"%ArrayPrototype%"
).
"length"
property is
numberOfArgs
.
The Array
When the
from
method is called with argument
items
and optional arguments
mapfn
and
thisArg
, the following steps are taken:
"length"
,
k
,
"length"
)).
"length"
,
len
,
The
from
function is an intentionally generic factory method; it does not require that its
The
isArray
function takes one argument
arg
, and performs the following steps:
When the
of
method is called with any number of arguments, the following steps are taken:
"length"
,
len
,
The items argument is assumed to be a well-formed rest argument value.
The
of
function is an intentionally generic factory method; it does not require that its
The value of
Array.prototype
is
This property has the attributes { [[Writable]]:
Array[@@species]
is an
The value of the
name
property of this function is
"get [Symbol.species]"
.
Array prototype methods normally use their
this
object's
The Array prototype object:
"length"
property whose initial value is 0 and whose attributes are { [[Writable]]:
The Array prototype object is specified to be an Array
When the
concat
method is called with zero or
more arguments, it returns an array containing the array elements of the
object followed by the array elements of each argument in order.
The following steps are taken:
"length"
)).
"length"
,
n
,
The
"length"
property of the
concat
method is 1.
The explicit setting of the
"length"
property
in step 6 is necessary to ensure that its value is correct in situations
where the trailing elements of the result Array are not present.
The
concat
function is intentionally generic; it does not require that its
The abstract operation IsConcatSpreadable with argument O performs the following steps:
The initial value of
Array.prototype.constructor
is the intrinsic object
The
copyWithin
method takes up to three arguments
target
,
start
and
end
.
The
end
argument is optional with the length of the
The following steps are taken:
"length"
)).
The
copyWithin
function is intentionally generic; it does not require that its
The following steps are taken:
"key+value"
).
This function is the %ArrayProto_entries% intrinsic object.
callbackfn
should be a function that accepts three arguments and returns a value that is coercible to the Boolean value
every
calls
callbackfn
once for each element present in the array, in ascending order, until it finds one where
callbackfn
returns
every
immediately returns
every
will return
If a
thisArg
parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
every
does not directly mutate the object on which it is called but the object may be mutated by the calls to
callbackfn
.
The range of elements processed by
every
is set before the first call to
callbackfn
. Elements which are appended to the array after the call to
every
begins will not be visited by
callbackfn
. If existing elements of the array are changed, their value as passed to
callbackfn
will be the value at the time
every
visits them; elements that are deleted after the call to
every
begins and before being visited are not visited.
every
acts like the "for all" quantifier in mathematics. In particular, for an empty array, it returns
When the
every
method is called with one or two arguments, the following steps are taken:
"length"
)).
The
every
function is intentionally generic; it does not require that its
The
fill
method takes up to three arguments
value
,
start
and
end
.
The
start
and
end
arguments are optional with default values of 0 and the length of the
The following steps are taken:
"length"
)).
The
fill
function is intentionally generic; it does not require that its
callbackfn
should be a function that accepts three arguments and returns a value that is coercible to the Boolean value
filter
calls
callbackfn
once for each element in the array, in ascending order, and constructs a new array of all the values for which
callbackfn
returns
If a
thisArg
parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
filter
does not directly mutate the object on which it is called but the object may be mutated by the calls to
callbackfn
.
The range of elements processed by
filter
is set before the first call to
callbackfn
. Elements which are appended to the array after the call to
filter
begins will not be visited by
callbackfn
. If existing elements of the array are changed their value as passed to
callbackfn
will be the value at the time
filter
visits them; elements that are deleted after the call to
filter
begins and before being visited are not visited.
When the
filter
method is called with one or two arguments, the following steps are taken:
"length"
)).
The
filter
function is intentionally generic; it does not require that its
The
find
method is called with one or two arguments,
predicate
and
thisArg
.
predicate
should be a function that accepts three arguments and returns a value that is coercible to a Boolean value.
find
calls
predicate
once for each element of the array, in ascending order, until it finds one where
predicate
returns
find
immediately returns that element value. Otherwise,
find
returns
If a
thisArg
parameter is provided, it will be used as the
predicate is called with three arguments: the value of the element, the index of the element, and the object being traversed.
find
does not directly mutate the object on which it is called but the object may be mutated by the calls to
predicate
.
The range of elements processed by
find
is set before the first call to
predicate
. Elements that are appended to the array after the call to
find
begins will not be visited by
predicate
. If existing elements of the array are changed, their value as passed to
predicate
will be the value at the time that
find
visits them.
When the
find
method is called, the following steps are taken:
"length"
)).
The
find
function is intentionally generic; it does not require that its
predicate
should be a function that accepts three arguments and returns a value that is coercible to the Boolean value
findIndex
calls
predicate
once for each element of the array, in ascending order, until it finds one where
predicate
returns
findIndex
immediately returns the index of that element value. Otherwise,
findIndex
returns -1.
If a
thisArg
parameter is provided, it will be used as the
predicate is called with three arguments: the value of the element, the index of the element, and the object being traversed.
findIndex
does not directly mutate the object on which it is called but the object may be mutated by the calls to
predicate
.
The range of elements processed by
findIndex
is set before the first call to
predicate
. Elements that are appended to the array after the call to
findIndex
begins will not be visited by
predicate
. If existing elements of the array are changed, their value as passed to
predicate
will be the value at the time that
findIndex
visits them.
When the
findIndex
method is called with one or two arguments, the following steps are taken:
"length"
)).
The
findIndex
function is intentionally generic; it does not require that its
When the
flat
method is called with zero or one arguments, the following steps are taken:
"length"
)).
"length"
)).
When the
flatMap
method is called with one or two arguments, the following steps are taken:
"length"
)).
callbackfn
should be a function that accepts three arguments.
forEach
calls
callbackfn
once for each element present in the array, in ascending order.
callbackfn
is called only for elements of the array which actually exist; it is not called for missing elements of the array.
If a
thisArg
parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
forEach
does not directly mutate the object on which it is called but the object may be mutated by the calls to
callbackfn
.
When the
forEach
method is called with one or two arguments, the following steps are taken:
"length"
)).
This function is the %ArrayProto_forEach% intrinsic object.
The
forEach
function is intentionally generic; it does not require that its
includes
compares
searchElement
to the elements of the array, in ascending order, using the
The optional second argument
fromIndex
defaults to 0 (i.e. the whole array is searched). If it is greater than or equal to the length of the array,
When the
includes
method is called, the following steps are taken:
"length"
)).
The
includes
function is intentionally generic; it does not require that its
The
includes
method intentionally differs from the similar
indexOf
method in two ways. First, it uses the
indexOf
compares
searchElement
to the elements of the array, in ascending order, using the
The optional second argument fromIndex defaults to 0 (i.e. the whole array is searched). If it is greater than or equal to the length of the array, -1 is returned, i.e. the array will not be searched. If it is negative, it is used as the offset from the end of the array to compute fromIndex . If the computed index is less than 0, the whole array will be searched.
When the
indexOf
method is called with one or two arguments, the following steps are taken:
"length"
)).
The
indexOf
function is intentionally generic; it does not require that its
The elements of the array are converted to Strings, and these Strings are then concatenated, separated by occurrences of the separator . If no separator is provided, a single comma is used as the separator.
The
join
method takes one argument,
separator
, and performs the following steps:
"length"
)).
","
.
The
join
function is intentionally generic; it does not require that its
The following steps are taken:
"key"
).
This function is the %ArrayProto_keys% intrinsic object.
lastIndexOf
compares
searchElement
to the elements of the array in descending order using the
The optional second argument fromIndex defaults to the array's length minus one (i.e. the whole array is searched). If it is greater than or equal to the length of the array, the whole array will be searched. If it is negative, it is used as the offset from the end of the array to compute fromIndex . If the computed index is less than 0, -1 is returned.
When the
lastIndexOf
method is called with one or two arguments, the following steps are taken:
"length"
)).
The
lastIndexOf
function is intentionally generic; it does not require that its
callbackfn
should be a function that accepts three arguments.
map
calls
callbackfn
once for each element in the array, in ascending order, and constructs a new Array from the results.
callbackfn
is called only for elements of the array which actually exist; it is not called for missing elements of the array.
If a
thisArg
parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
map
does not directly mutate the object on which it is called but the object may be mutated by the calls to
callbackfn
.
The range of elements processed by
map
is set before the first call to
callbackfn
. Elements which are appended to the array after the call to
map
begins will not be visited by
callbackfn
. If existing elements of the array are changed, their value as passed to
callbackfn
will be the value at the time
map
visits them; elements that are deleted after the call to
map
begins and before being visited are not visited.
When the
map
method is called with one or two arguments, the following steps are taken:
"length"
)).
The
map
function is intentionally generic; it does not require that its
The last element of the array is removed from the array and returned.
When the
pop
method is called, the following steps are taken:
"length"
)).
"length"
, 0,
"length"
,
newLen
,
The
pop
function is intentionally generic; it does not require that its
The arguments are appended to the end of the array, in the order in which they appear. The new length of the array is returned as the result of the call.
When the
push
method is called with zero or more arguments, the following steps are taken:
"length"
)).
"length"
,
len
,
The
"length"
property of the
push
method is 1.
The
push
function is intentionally generic; it does not require that its
callbackfn
should be a function that takes four arguments.
reduce
calls the callback, as a function, once for each element after the first element present in the array, in ascending order.
callbackfn
is called with four arguments: the
previousValue
(value from the previous call to
callbackfn
), the
currentValue
(value of the current element), the
currentIndex
, and the object being traversed. The first time that callback is called, the
previousValue
and
currentValue
can be one of two values. If an
initialValue
was supplied in the call to
reduce
, then
previousValue
will be equal to
initialValue
and
currentValue
will be equal to the first value in the array. If no
initialValue
was supplied, then
previousValue
will be equal to the first value in the array and
currentValue
will be equal to the second. It is a
reduce
does not directly mutate the object on which it is called but the object may be mutated by the calls to
callbackfn
.
The range of elements processed by
reduce
is set before the first call to
callbackfn
. Elements that are appended to the array after the call to
reduce
begins will not be visited by
callbackfn
. If existing elements of the array are changed, their value as passed to
callbackfn
will be the value at the time
reduce
visits them; elements that are deleted after the call to
reduce
begins and before being visited are not visited.
When the
reduce
method is called with one or two arguments, the following steps are taken:
"length"
)).
The
reduce
function is intentionally generic; it does not require that its
callbackfn
should be a function that takes four arguments.
reduceRight
calls the callback, as a function, once for each element after the first element present in the array, in descending order.
callbackfn
is called with four arguments: the
previousValue
(value from the previous call to
callbackfn
), the
currentValue
(value of the current element), the
currentIndex
, and the object being traversed. The first time the function is called, the
previousValue
and
currentValue
can be one of two values. If an
initialValue
was supplied in the call to
reduceRight
, then
previousValue
will be equal to
initialValue
and
currentValue
will be equal to the last value in the array. If no
initialValue
was supplied, then
previousValue
will be equal to the last value in the array and
currentValue
will be equal to the second-to-last value. It is a
reduceRight
does not directly mutate the object on which it is called but the object may be mutated by the calls to
callbackfn
.
The range of elements processed by
reduceRight
is set before the first call to
callbackfn
. Elements that are appended to the array after the call to
reduceRight
begins will not be visited by
callbackfn
. If existing elements of the array are changed by
callbackfn
, their value as passed to
callbackfn
will be the value at the time
reduceRight
visits them; elements that are deleted after the call to
reduceRight
begins and before being visited are not visited.
When the
reduceRight
method is called with one or two arguments, the following steps are taken:
"length"
)).
The
reduceRight
function is intentionally
generic; it does not require that its this value be an Array object.
Therefore it can be transferred to other kinds of objects for use as a
method.
The elements of the array are rearranged so as to reverse their order. The object is returned as the result of the call.
When the
reverse
method is called, the following steps are taken:
"length"
)).
The
reverse
function is intentionally generic; it does not require that its
The first element of the array is removed from the array and returned.
When the
shift
method is called, the following steps are taken:
"length"
)).
"length"
, 0,
"0"
).
"length"
,
len
- 1,
The
shift
function is intentionally generic; it does not require that its
The
slice
method takes two arguments,
start
and
end
, and returns an array containing the elements of the array from element
start
up to, but not including, element
end
(or through the end of the array if
end
is
The following steps are taken:
"length"
)).
"length"
,
n
,
The explicit setting of the
"length"
property
of the result Array in step 11 was necessary in previous editions of
ECMAScript to ensure that its length was correct in situations where the
trailing elements of the result Array were not present. Setting
"length"
became unnecessary starting in ES2015 when the result Array was
initialized to its proper length rather than an empty Array but is
carried forward to preserve backward compatibility.
The
slice
function is intentionally generic; it does not require that its
callbackfn
should be a function that accepts three arguments and returns a value that is coercible to the Boolean value
some
calls
callbackfn
once for each element present in the array, in ascending order, until it finds one where
callbackfn
returns
some
immediately returns
some
returns
If a
thisArg
parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
some
does not directly mutate the object on which it is called but the object may be mutated by the calls to
callbackfn
.
The range of elements processed by
some
is set before the first call to
callbackfn
. Elements that are appended to the array after the call to
some
begins will not be visited by
callbackfn
. If existing elements of the array are changed, their value as passed to
callbackfn
will be the value at the time that
some
visits them; elements that are deleted after the call to
some
begins and before being visited are not visited.
some
acts like the "exists" quantifier in mathematics. In particular, for an empty array, it returns
When the
some
method is called with one or two arguments, the following steps are taken:
"length"
)).
The
some
function is intentionally generic; it does not require that its
The elements of this array are sorted. The sort must be
stable (that is, elements that compare equal must remain in their
original order). If
comparefn
is not
Upon entry, the following steps are performed to initialize evaluation of the
sort
function:
"length"
)).
Within this specification of the
sort
method, an object,
obj
, is said to be
sparse
if the following algorithm returns
The
sort order
is the ordering, after completion of this function, of the
sort
function is then determined as follows:
If
comparefn
is not
Let
proto
be
obj
.[[GetPrototypeOf]](). If
proto
is not
The sort order is also implementation-defined if obj is sparse and any of the following conditions are true:
The sort order is also implementation-defined if any of the following conditions are true:
The following steps are taken:
Unless the sort order is specified above to be implementation-defined, the returned object must have the following two characteristics:
Here the notation
A function
comparefn
is a consistent comparison function for a set of values
S
if all of the requirements below are met for all values
a
,
b
, and
c
(possibly the same value) in the set
S
: The notation
The above conditions are necessary and sufficient to ensure that comparefn divides the set S into equivalence classes and that these equivalence classes are totally ordered.
The
sort
function is intentionally generic; it does not require that its
The SortCompare abstract operation is called with two arguments
x
and
y
. It also has access to the
comparefn
argument passed to the current invocation of the
sort
method. The following steps are taken:
Because non-existent property values always compare greater than
Method calls performed by the
When the
splice
method is called with two or more arguments
start
,
deleteCount
and zero or more
items
, the
deleteCount
elements of the array starting at
The following steps are taken:
"length"
)).
"length"
,
actualDeleteCount
,
"length"
,
len
-
actualDeleteCount
+
itemCount
,
The explicit setting of the
"length"
property
of the result Array in step 19 was necessary in previous editions of
ECMAScript to ensure that its length was correct in situations where the
trailing elements of the result Array were not present. Setting
"length"
became unnecessary starting in ES2015 when the result Array was
initialized to its proper length rather than an empty Array but is
carried forward to preserve backward compatibility.
The
splice
function is intentionally generic; it does not require that its
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the
Array.prototype.toLocaleString
method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following
specification of the
toLocaleString
method is used.
The first edition of ECMA-402 did not include a replacement specification for the
Array.prototype.toLocaleString
method.
The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
The following steps are taken:
"length"
)).
"toLocaleString"
)).
The elements of the array are converted to Strings using their
toLocaleString
methods, and these Strings are then concatenated, separated by
occurrences of a separator String that has been derived in an
implementation-defined locale-specific way. The result of calling this
function is intended to be analogous to the result of
toString
, except that the result of this function is intended to be locale-specific.
The
toLocaleString
function is intentionally generic; it does not require that its
When the
toString
method is called, the following steps are taken:
"join"
).
The
toString
function is intentionally generic; it does not require that its
The arguments are prepended to the start of the array, such that their order within the array is the same as the order in which they appear in the argument list.
When the
unshift
method is called with zero or more arguments
item1
,
item2
, etc., the following steps are taken:
"length"
)).
"length"
,
len
+
argCount
,
The
"length"
property of the
unshift
method is 1.
The
unshift
function is intentionally generic; it does not require that its
The following steps are taken:
"value"
).
This function is the %ArrayProto_values% intrinsic object.
The initial value of the @@iterator property is the same
Array.prototype.values
property.
The initial value of the @@unscopables
"copyWithin"
,
"entries"
,
"fill"
,
"find"
,
"findIndex"
,
"flat"
,
"flatMap"
,
"includes"
,
"keys"
,
"values"
,
This property has the attributes { [[Writable]]:
The own property names of this object are property names that were not included as standard properties of
Array.prototype
prior to the ECMAScript 2015 specification. These names are ignored for
with
statement binding purposes in order to preserve the behaviour of
existing code that might use one of these names as a binding in an outer
scope that is shadowed by a
with
statement whose binding object is an Array object.
Array instances are Array exotic objects and have the internal methods specified for such objects. Array instances inherit properties from the Array prototype object.
Array instances have a
"length"
property, and a set of enumerable properties with
The
"length"
property of an Array instance is a
The
"length"
property initially has the attributes { [[Writable]]:
Reducing the value of the
"length"
property has the side-effect of deleting own array elements whose
"length"
property of an Array object to a value that is numerically less than or equal to the largest numeric own
An Array Iterator is an object, that represents a specific
iteration over some specific Array instance object. There is not a named
Several methods of Array objects return Iterator objects. The abstract operation CreateArrayIterator with arguments array and kind is used to create such iterator objects. It performs the following steps:
The %ArrayIteratorPrototype% object:
"key"
, return
"value"
, let
result
be
elementValue
.
"key+value"
.
The initial value of the @@toStringTag property is the String value
"Array Iterator"
.
This property has the attributes { [[Writable]]:
Array Iterator instances are ordinary objects that inherit properties from the
| Internal Slot | Description |
|---|---|
| [[IteratedObject]] | The object whose array elements are being iterated. |
| [[ArrayIteratorNextIndex]] |
The
|
| [[ArrayIterationKind]] |
A String value that identifies what is returned for each element of the iteration. The possible values are:
"key"
,
"value"
,
"key+value"
.
|
TypedArray
objects present an array-like view of an underlying binary data buffer (
|
|
Element Type | Element Size | Conversion Operation | Description | Equivalent C Type |
|---|---|---|---|---|---|
|
Int8Array
%Int8Array% |
Int8 | 1 |
|
8-bit 2's complement signed integer | signed char |
|
Uint8Array
%Uint8Array% |
Uint8 | 1 |
|
8-bit unsigned integer | unsigned char |
|
Uint8ClampedArray
%Uint8ClampedArray% |
Uint8C | 1 |
|
8-bit unsigned integer (clamped conversion) | unsigned char |
|
Int16Array
%Int16Array% |
Int16 | 2 |
|
16-bit 2's complement signed integer | short |
|
Uint16Array
%Uint16Array% |
Uint16 | 2 |
|
16-bit unsigned integer | unsigned short |
|
Int32Array
%Int32Array% |
Int32 | 4 |
|
32-bit 2's complement signed integer | int |
|
Uint32Array
%Uint32Array% |
Uint32 | 4 |
|
32-bit unsigned integer | unsigned int |
|
Float32Array
%Float32Array% |
Float32 | 4 | 32-bit IEEE floating point | float | |
|
Float64Array
%Float64Array% |
Float64 | 8 | 64-bit IEEE floating point | double |
In the definitions below, references to
TypedArray
should be replaced with the appropriate
The %TypedArray% intrinsic object:
super
call to it.
The
The
"length"
property of the
The
name
property whose value is
"TypedArray"
.
When the
from
method is called with argument
source
, and optional arguments
mapfn
and
thisArg
, the following steps are taken:
"length"
)).
The abstract operation IterableToList performs the following steps:
When the
of
method is called with any number of arguments, the following steps are taken:
The items argument is assumed to be a well-formed rest argument value.
The initial value of
.prototype
is the
This property has the attributes { [[Writable]]:
[@@species]
is an
The value of the
name
property of this function is
"get [Symbol.species]"
.
this
object's
The %TypedArrayPrototype% object:
.prototype.buffer
is an
.prototype.byteLength
is an
.prototype.byteOffset
is an
The initial value of
.prototype.constructor
is the
The interpretation and use of the arguments of
.prototype.copyWithin
are the same as for
Array.prototype.copyWithin
as defined in
The following steps are taken:
"Uint8"
,
"Unordered"
).
"Uint8"
,
value
,
"Unordered"
).
When called with argument O , the following steps are taken:
The following steps are taken:
"key+value"
).
.prototype.every
is a distinct function that implements the same algorithm as
Array.prototype.every
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
The interpretation and use of the arguments of
.prototype.fill
are the same as for
Array.prototype.fill
as defined in
The following steps are taken:
The interpretation and use of the arguments of
.prototype.filter
are the same as for
Array.prototype.filter
as defined in
When the
filter
method is called with one or two arguments, the following steps are taken:
This function is not generic. The
.prototype.find
is a distinct function that implements the same algorithm as
Array.prototype.find
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.findIndex
is a distinct function that implements the same algorithm as
Array.prototype.findIndex
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.forEach
is a distinct function that implements the same algorithm as
Array.prototype.forEach
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.includes
is a distinct function that implements the same algorithm as
Array.prototype.includes
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.indexOf
is a distinct function that implements the same algorithm as
Array.prototype.indexOf
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.join
is a distinct function that implements the same algorithm as
Array.prototype.join
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
The following steps are taken:
"key"
).
.prototype.lastIndexOf
is a distinct function that implements the same algorithm as
Array.prototype.lastIndexOf
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.length
is an
This function is not generic. The
The interpretation and use of the arguments of
.prototype.map
are the same as for
Array.prototype.map
as defined in
When the
map
method is called with one or two arguments, the following steps are taken:
This function is not generic. The
.prototype.reduce
is a distinct function that implements the same algorithm as
Array.prototype.reduce
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.reduceRight
is a distinct function that implements the same algorithm as
Array.prototype.reduceRight
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.reverse
is a distinct function that implements the same algorithm as
Array.prototype.reverse
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.set
is a single function whose behaviour is overloaded based upon the type of its first argument.
This function is not generic. The
Sets multiple values in this TypedArray , reading the values from the object array . The optional offset value indicates the first element index in this TypedArray where values are written. If omitted, it is assumed to be 0.
"length"
)).
"Unordered"
).
Sets multiple values in this TypedArray , reading the values from the typedArray argument object. The optional offset value indicates the first element index in this TypedArray where values are written. If omitted, it is assumed to be 0.
"Uint8"
,
"Unordered"
).
"Uint8"
,
value
,
"Unordered"
).
"Unordered"
).
"Unordered"
).
The interpretation and use of the arguments of
.prototype.slice
are the same as for
Array.prototype.slice
as defined in
"Uint8"
,
"Unordered"
).
"Uint8"
,
value
,
"Unordered"
).
This function is not generic. The
.prototype.some
is a distinct function that implements the same algorithm as
Array.prototype.some
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
.prototype.sort
is a distinct function that, except as described below, implements the same requirements as those of
Array.prototype.sort
as defined in
.prototype.sort
specification may be optimized with the knowledge that the
This function is not generic. The
Upon entry, the following steps are performed to initialize evaluation of the
sort
function. These steps are used instead of the entry steps in
The implementation-defined sort order condition for exotic objects is not applied by
.prototype.sort
.
The following version of
.prototype.sort
. It performs a numeric comparison rather than the string comparison used in
sort
method.
When the TypedArray
Because
Returns a new TypedArray object whose element type is the same as this TypedArray and whose ArrayBuffer is the same as the ArrayBuffer of this TypedArray , referencing the elements at begin , inclusive, up to end , exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.
This function is not generic. The
.prototype.toLocaleString
is a distinct function that implements the same algorithm as
Array.prototype.toLocaleString
as defined in
"length"
. The implementation of the algorithm may be optimized with the knowledge that the
This function is not generic.
If the ECMAScript implementation includes the ECMA-402 Internationalization API this function is based upon the algorithm for
Array.prototype.toLocaleString
that is in the ECMA-402 specification.
The initial value of the
.prototype.toString
Array.prototype.toString
method defined in
The following steps are taken:
"value"
).
The initial value of the @@iterator property is the same
.prototype.values
property.
.prototype[@@toStringTag]
is an
This property has the attributes { [[Enumerable]]:
The initial value of the
name
property of this function is
"get [Symbol.toStringTag]"
.
Each
TypedArray
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
TypedArray
behaviour must include a
super
call to the
TypedArray
.prototype
built-in methods.
"length"
property whose value is 3.
This description applies only if the TypedArray function is called with no arguments.
"%
TypedArray
Prototype%"
, 0).
This description applies only if the TypedArray function is called with at least one argument and the Type of the first argument is not Object.
TypedArray called with argument length performs the following steps:
"%
TypedArray
Prototype%"
,
elementLength
).
The abstract operation AllocateTypedArray with arguments
constructorName
,
newTarget
,
defaultProto
and optional argument
length
is used to validate and create an instance of a TypedArray
The abstract operation AllocateTypedArrayBuffer with arguments O and length allocates and associates an ArrayBuffer with the TypedArray instance O . It performs the following steps:
This description applies only if the TypedArray function is called with at least one argument and the Type of the first argument is Object and that object has a [[TypedArrayName]] internal slot.
TypedArray called with argument typedArray performs the following steps:
"%
TypedArray
Prototype%"
).
"Unordered"
).
"Unordered"
).
This description applies only if the TypedArray function is called with at least one argument and the Type of the first argument is Object and that object does not have either a [[TypedArrayName]] or an [[ArrayBufferData]] internal slot.
TypedArray called with argument object performs the following steps:
"%
TypedArray
Prototype%"
).
"length"
)).
This description applies only if the TypedArray function is called with at least one argument and the Type of the first argument is Object and that object has an [[ArrayBufferData]] internal slot.
TypedArray called with at least one argument buffer performs the following steps:
"%
TypedArray
Prototype%"
).
The abstract operation TypedArrayCreate with arguments
constructor
and
argumentList
is used to specify the creation of a new TypedArray object using a
The abstract operation TypedArraySpeciesCreate with arguments
exemplar
and
argumentList
is used to specify the creation of a new TypedArray object using a
Each
TypedArray
name
property whose value is the String value of the
The value of
TypedArray
.BYTES_PER_ELEMENT is the Number value of the Element Size value specified in
This property has the attributes { [[Writable]]:
The initial value of
TypedArray
.prototype
is the corresponding
TypedArray
prototype intrinsic object (
This property has the attributes { [[Writable]]:
Each TypedArray prototype object:
The value of
TypedArray
.prototype.BYTES_PER_ELEMENT
is the Number value of the Element Size value specified in
This property has the attributes { [[Writable]]:
The initial value of a
TypedArray
.prototype.constructor
is the corresponding %
TypedArray
% intrinsic object.
TypedArray
instances are
Map objects are collections of key/value pairs where both the
keys and values may be arbitrary ECMAScript language values. A distinct
key value may only occur in one key/value pair within the Map's
collection. Distinct key values are discriminated using the
Map object must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structures used in this Map objects specification is only intended to describe the required observable semantics of Map objects. It is not intended to be a viable implementation model.
The Map
Map
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
Map
behaviour must include a
super
call to the
Map
Map.prototype
built-in methods.
When the
Map
function is called with optional argument
iterable
, the following steps are taken:
"%MapPrototype%"
, « [[MapData]] »).
"set"
).
If the parameter iterable is present, it is expected to be an object that implements an @@iterator method that returns an iterator object that produces a two element array-like object whose first element is a value that will be used as a Map key and whose second element is the value to associate with that key.
The abstract operation AddEntriesFromIterable accepts a target object, an iterable of entries, and an adder function to be invoked, with target as the receiver.
"0"
).
"1"
).
The parameter iterable is expected to be an object that implements an @@iterator method that returns an iterator object that produces a two element array-like object whose first element is a value that will be used as a Map key and whose second element is the value to associate with that key.
The Map
The initial value of
Map.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
Map[@@species]
is an
The value of the
name
property of this function is
"get [Symbol.species]"
.
Methods that create derived collection objects should call @@species to determine the
The Map prototype object:
The following steps are taken:
The initial value of
Map.prototype.constructor
is the intrinsic object
The following steps are taken:
The value
The following steps are taken:
"key+value"
).
When the
forEach
method is called with one or two arguments, the following steps are taken:
callbackfn
should be a function that accepts three arguments.
forEach
calls
callbackfn
once for each key/value pair present in the map object, in key insertion order.
callbackfn
is called only for keys of the map which actually exist; it is not called for keys that have been deleted from the map.
If a
thisArg
parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the item, the key of the item, and the Map object being traversed.
forEach
does not directly mutate the object on which it is called but the object may be mutated by the calls to
callbackfn
. Each entry of a map's [[MapData]] is only visited once. New keys added after the call to
forEach
begins are visited. A key will be revisited if it is deleted after it has been visited and then re-added before the
forEach
call completes. Keys that are deleted after the call to
forEach
begins and before being visited are not visited unless the key is added again before the
forEach
call completes.
The following steps are taken:
The following steps are taken:
The following steps are taken:
"key"
).
The following steps are taken:
Map.prototype.size
is an
The following steps are taken:
"value"
).
The initial value of the @@iterator property is the same
entries
property.
The initial value of the @@toStringTag property is the String value
"Map"
.
This property has the attributes { [[Writable]]:
Map instances are ordinary objects that inherit properties from the Map prototype. Map instances also have a [[MapData]] internal slot.
A Map Iterator is an object, that represents a specific iteration over some specific Map instance object. There is not a named
Several methods of Map objects return Iterator objects. The abstract operation CreateMapIterator with arguments map and kind is used to create such iterator objects. It performs the following steps:
The %MapIteratorPrototype% object:
"key"
, let
result
be
e
.[[Key]].
"value"
, let
result
be
e
.[[Value]].
"key+value"
.
The initial value of the @@toStringTag property is the String value
"Map Iterator"
.
This property has the attributes { [[Writable]]:
Map Iterator instances are ordinary objects that inherit properties from the
| Internal Slot | Description |
|---|---|
| [[Map]] | The Map object that is being iterated. |
| [[MapNextIndex]] |
The
|
| [[MapIterationKind]] |
A String value that identifies what is to be returned
for each element of the iteration. The possible values are:
"key"
,
"value"
,
"key+value"
.
|
Set objects are collections of ECMAScript language values. A
distinct value may only occur once as an element of a Set's collection.
Distinct values are discriminated using the
Set objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structures used in this Set objects specification is only intended to describe the required observable semantics of Set objects. It is not intended to be a viable implementation model.
The Set
Set
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
Set
behaviour must include a
super
call to the
Set
Set.prototype
built-in methods.
When the
Set
function is called with optional argument
iterable
, the following steps are taken:
"%SetPrototype%"
, « [[SetData]] »).
"add"
).
The Set
The initial value of
Set.prototype
is the intrinsic
This property has the attributes { [[Writable]]:
Set[@@species]
is an
The value of the
name
property of this function is
"get [Symbol.species]"
.
Methods that create derived collection objects should call @@species to determine the
The Set prototype object:
The following steps are taken:
The following steps are taken:
The initial value of
Set.prototype.constructor
is the intrinsic object
The following steps are taken:
The value
The following steps are taken:
"key+value"
).
For iteration purposes, a Set appears similar to a Map where each entry has the same value for its key and value.
When the
forEach
method is called with one or two arguments, the following steps are taken:
callbackfn
should be a function that accepts three arguments.
forEach
calls
callbackfn
once for each value present in the set object, in value insertion order.
callbackfn
is called only for values of the Set which actually exist; it is not called for keys that have been deleted from the set.
If a
thisArg
parameter is provided, it will be used as the
callbackfn is called with three arguments: the first two arguments are a value contained in the Set. The same value is passed for both arguments. The Set object being traversed is passed as the third argument.
The
callbackfn
is called with three arguments to be consistent with the call back functions used by
forEach
methods for Map and Array. For Sets, each item value is considered to be both the key and the value.
forEach
does not directly mutate the object on which it is called but the object may be mutated by the calls to
callbackfn
.
Each value is normally visited only once. However, a value
will be revisited if it is deleted after it has been visited and then
re-added before the
forEach
call completes. Values that are deleted after the call to
forEach
begins and before being visited are not visited unless the value is added again before the
forEach
call completes. New values added after the call to
forEach
begins are visited.
The following steps are taken:
The initial value of the
keys
property is the same
values
property.
For iteration purposes, a Set appears similar to a Map where each entry has the same value for its key and value.
Set.prototype.size
is an
The following steps are taken:
"value"
).
The initial value of the @@iterator property is the same
values
property.
The initial value of the @@toStringTag property is the String value
"Set"
.
This property has the attributes { [[Writable]]:
Set instances are ordinary objects that inherit properties from the Set prototype. Set instances also have a [[SetData]] internal slot.
A Set Iterator is an ordinary object, with the structure
defined below, that represents a specific iteration over some specific
Set instance object. There is not a named
Several methods of Set objects return Iterator objects. The abstract operation CreateSetIterator with arguments set and kind is used to create such iterator objects. It performs the following steps:
The %SetIteratorPrototype% object:
"key+value"
, then
The initial value of the @@toStringTag property is the String value
"Set Iterator"
.
This property has the attributes { [[Writable]]:
Set Iterator instances are ordinary objects that inherit properties from the
| Internal Slot | Description |
|---|---|
| [[IteratedSet]] | The Set object that is being iterated. |
| [[SetNextIndex]] |
The
|
| [[SetIterationKind]] |
A String value that identifies what is to be returned
for each element of the iteration. The possible values are:
"key"
,
"value"
,
"key+value"
.
"key"
and
"value"
have the same meaning.
|
WeakMap objects are collections of key/value pairs where the keys are objects and values may be arbitrary ECMAScript language values. A WeakMap may be queried to see if it contains a key/value pair with a specific key, but no mechanism is provided for enumerating the objects it holds as keys. If an object that is being used as the key of a WeakMap key/value pair is only reachable by following a chain of references that start within that WeakMap, then that key/value pair is inaccessible and is automatically removed from the WeakMap. WeakMap implementations must detect and remove such key/value pairs and any associated resources.
An implementation may impose an arbitrarily determined latency between the time a key/value pair of a WeakMap becomes inaccessible and the time when the key/value pair is removed from the WeakMap. If this latency was observable to ECMAScript program, it would be a source of indeterminacy that could impact program execution. For that reason, an ECMAScript implementation must not provide any means to observe a key of a WeakMap that does not require the observer to present the observed key.
WeakMap objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of key/value pairs in the collection. The data structure used in this WeakMap objects specification are only intended to describe the required observable semantics of WeakMap objects. It is not intended to be a viable implementation model.
WeakMap and WeakSets are intended to provide mechanisms for dynamically associating state with an object in a manner that does not “leak” memory resources if, in the absence of the WeakMap or WeakSet, the object otherwise became inaccessible and subject to resource reclamation by the implementation's garbage collection mechanisms. This characteristic can be achieved by using an inverted per-object mapping of weak map instances to keys. Alternatively each weak map may internally store its key to value mappings but this approach requires coordination between the WeakMap or WeakSet implementation and the garbage collector. The following references describe mechanism that may be useful to implementations of WeakMap and WeakSets:
Barry Hayes. 1997. Ephemerons: a new finalization mechanism. In Proceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (OOPSLA '97) , A. Michael Berman (Ed.). ACM, New York, NY, USA, 176-183, http://doi.acm.org/10.1145/263698.263733 .
Alexandra Barros, Roberto Ierusalimschy, Eliminating Cycles in Weak Tables. Journal of Universal Computer Science - J.UCS, vol. 14, no. 21, pp. 3481-3497, 2008, http://www.jucs.org/jucs_14_21/eliminating_cycles_in_weak
The WeakMap
WeakMap
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
WeakMap
behaviour must include a
super
call to the
WeakMap
WeakMap.prototype
built-in methods.
When the
WeakMap
function is called with optional argument
iterable
, the following steps are taken:
"%WeakMapPrototype%"
, « [[WeakMapData]] »).
"set"
).
If the parameter iterable is present, it is expected to be an object that implements an @@iterator method that returns an iterator object that produces a two element array-like object whose first element is a value that will be used as a WeakMap key and whose second element is the value to associate with that key.
The WeakMap
The initial value of
WeakMap.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The WeakMap prototype object:
The initial value of
WeakMap.prototype.constructor
is the intrinsic object
The following steps are taken:
The value
The following steps are taken:
The following steps are taken:
The following steps are taken:
The initial value of the @@toStringTag property is the String value
"WeakMap"
.
This property has the attributes { [[Writable]]:
WeakMap instances are ordinary objects that inherit properties from the WeakMap prototype. WeakMap instances also have a [[WeakMapData]] internal slot.
WeakSet objects are collections of objects. A distinct object may only occur once as an element of a WeakSet's collection. A WeakSet may be queried to see if it contains a specific object, but no mechanism is provided for enumerating the objects it holds. If an object that is contained by a WeakSet is only reachable by following a chain of references that start within that WeakSet, then that object is inaccessible and is automatically removed from the WeakSet. WeakSet implementations must detect and remove such objects and any associated resources.
An implementation may impose an arbitrarily determined latency between the time an object contained in a WeakSet becomes inaccessible and the time when the object is removed from the WeakSet. If this latency was observable to ECMAScript program, it would be a source of indeterminacy that could impact program execution. For that reason, an ECMAScript implementation must not provide any means to determine if a WeakSet contains a particular object that does not require the observer to present the observed object.
WeakSet objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structure used in this WeakSet objects specification is only intended to describe the required observable semantics of WeakSet objects. It is not intended to be a viable implementation model.
See the NOTE in
The WeakSet
WeakSet
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
WeakSet
behaviour must include a
super
call to the
WeakSet
WeakSet.prototype
built-in methods.
When the
WeakSet
function is called with optional argument
iterable
, the following steps are taken:
"%WeakSetPrototype%"
, « [[WeakSetData]] »).
"add"
).
The WeakSet
The initial value of
WeakSet.prototype
is the intrinsic
This property has the attributes { [[Writable]]:
The WeakSet prototype object:
The following steps are taken:
The initial value of
WeakSet.prototype.constructor
is the
The following steps are taken:
The value
The following steps are taken:
The initial value of the @@toStringTag property is the String value
"WeakSet"
.
This property has the attributes { [[Writable]]:
WeakSet instances are ordinary objects that inherit properties from the WeakSet prototype. WeakSet instances also have a [[WeakSetData]] internal slot.
The abstract operation AllocateArrayBuffer with arguments constructor and byteLength is used to create an ArrayBuffer object. It performs the following steps:
"%ArrayBufferPrototype%"
, « [[ArrayBufferData]], [[ArrayBufferByteLength]], [[ArrayBufferDetachKey]] »).
The abstract operation IsDetachedBuffer with argument arrayBuffer performs the following steps:
The abstract operation DetachArrayBuffer with argument arrayBuffer and optional argument key performs the following steps:
Detaching an ArrayBuffer instance disassociates the
The abstract operation CloneArrayBuffer takes four parameters, an ArrayBuffer
srcBuffer
, an integer offset
srcByteOffset
, an integer length
srcLength
, and a
The abstract operation RawBytesToNumber takes three parameters, a String
type
, a
"Float32"
, then
"Float64"
, then
The abstract operation GetValueFromBuffer takes six parameters, an ArrayBuffer or SharedArrayBuffer arrayBuffer , an integer byteIndex , a String type , a Boolean isTypedArray , a String order , and optionally a Boolean isLittleEndian . This operation performs the following steps:
"Int8"
,
"Uint8"
,
"Int16"
,
"Uint16"
,
"Int32"
, or
"Uint32"
, let
noTear
be
The abstract operation NumberToRawBytes takes three parameters, a String type , a Number value , and a Boolean isLittleEndian . This operation performs the following steps:
"Float32"
, then
"Float64"
, then
The abstract operation SetValueInBuffer takes seven parameters, an ArrayBuffer or SharedArrayBuffer arrayBuffer , an integer byteIndex , a String type , a Number value , a Boolean isTypedArray , a String order , and optionally a Boolean isLittleEndian . This operation performs the following steps:
"Int8"
,
"Uint8"
,
"Int16"
,
"Uint16"
,
"Int32"
, or
"Uint32"
, let
noTear
be
The abstract operation GetModifySetValueInBuffer takes six parameters, a SharedArrayBuffer arrayBuffer , a nonnegative integer byteIndex , a String type , a Number value , a semantic function op , and optionally a Boolean isLittleEndian . This operation performs the following steps:
"SeqCst"
, [[NoTear]]:
The ArrayBuffer
ArrayBuffer
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
ArrayBuffer
behaviour must include a
super
call to the
ArrayBuffer
ArrayBuffer.prototype
built-in methods.
When the
ArrayBuffer
function is called with argument
length
, the following steps are taken:
The ArrayBuffer
The
isView
function takes one argument
arg
, and performs the following steps:
The initial value of
ArrayBuffer.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
ArrayBuffer[@@species]
is an
The value of the
name
property of this function is
"get [Symbol.species]"
.
ArrayBuffer prototype methods normally use their
this
object's
The ArrayBuffer prototype object:
ArrayBuffer.prototype.byteLength
is an
The initial value of
ArrayBuffer.prototype.constructor
is the intrinsic object
The following steps are taken:
The initial value of the @@toStringTag property is the String value
"ArrayBuffer"
.
This property has the attributes { [[Writable]]:
ArrayBuffer instances inherit properties from the ArrayBuffer prototype object. ArrayBuffer instances each have an [[ArrayBufferData]] internal slot, an [[ArrayBufferByteLength]] internal slot, and an [[ArrayBufferDetachKey]] internal slot.
ArrayBuffer instances whose [[ArrayBufferData]] is
ArrayBuffer instances whose [[ArrayBufferDetachKey]] is set to a value other than
The abstract operation AllocateSharedArrayBuffer with arguments constructor and byteLength is used to create a SharedArrayBuffer object. It performs the following steps:
"%SharedArrayBufferPrototype%"
, « [[ArrayBufferData]], [[ArrayBufferByteLength]] »).
IsSharedArrayBuffer tests whether an object is an ArrayBuffer, a SharedArrayBuffer, or a subtype of either. It performs the following steps:
The SharedArrayBuffer
SharedArrayBuffer
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
SharedArrayBuffer
behaviour must include a
super
call to the
SharedArrayBuffer
SharedArrayBuffer.prototype
built-in methods.
Unlike an
ArrayBuffer
, a
SharedArrayBuffer
cannot become detached, and its internal [[ArrayBufferData]] slot is never
When the
SharedArrayBuffer
function is called with optional argument
length
, the following steps are taken:
The SharedArrayBuffer
The initial value of
SharedArrayBuffer.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
SharedArrayBuffer[@@species]
is an
The value of the
name
property of this function is
"get [Symbol.species]"
.
The SharedArrayBuffer prototype object:
SharedArrayBuffer.prototype.byteLength
is an
The initial value of
SharedArrayBuffer.prototype.constructor
is the intrinsic object
The following steps are taken:
The initial value of the @@toStringTag property is the String value
"SharedArrayBuffer"
.
This property has the attributes { [[Writable]]:
SharedArrayBuffer instances inherit properties from the SharedArrayBuffer prototype object. SharedArrayBuffer instances each have an [[ArrayBufferData]] internal slot and an [[ArrayBufferByteLength]] internal slot.
SharedArrayBuffer instances, unlike ArrayBuffer instances, are never detached.
The abstract operation GetViewValue with arguments view , requestIndex , isLittleEndian , and type is used by functions on DataView instances to retrieve values from the view's buffer. It performs the following steps:
"Unordered"
,
isLittleEndian
).
The abstract operation SetViewValue with arguments view , requestIndex , isLittleEndian , type , and value is used by functions on DataView instances to store values into the view's buffer. It performs the following steps:
"Unordered"
,
isLittleEndian
).
The DataView
DataView
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
DataView
behaviour must include a
super
call to the
DataView
DataView.prototype
built-in methods.
When the
DataView
function is called with at least one argument
buffer
, the following steps are taken:
"%DataViewPrototype%"
, « [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], [[ByteOffset]] »).
The DataView
The initial value of
DataView.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The DataView prototype object:
DataView.prototype.buffer
is an
DataView.prototype.byteLength
is an
DataView.prototype.byteOffset
is an
The initial value of
DataView.prototype.constructor
is the intrinsic object
When the
getFloat32
method is called with argument
byteOffset
and optional argument
littleEndian
, the following steps are taken:
"Float32"
).
When the
getFloat64
method is called with argument
byteOffset
and optional argument
littleEndian
, the following steps are taken:
"Float64"
).
When the
getInt8
method is called with argument
byteOffset
, the following steps are taken:
"Int8"
).
When the
getInt16
method is called with argument
byteOffset
and optional argument
littleEndian
, the following steps are taken:
"Int16"
).
When the
getInt32
method is called with argument
byteOffset
and optional argument
littleEndian
, the following steps are taken:
"Int32"
).
When the
getUint8
method is called with argument
byteOffset
, the following steps are taken:
"Uint8"
).
When the
getUint16
method is called with argument
byteOffset
and optional argument
littleEndian
, the following steps are taken:
"Uint16"
).
When the
getUint32
method is called with argument
byteOffset
and optional argument
littleEndian
, the following steps are taken:
"Uint32"
).
When the
setFloat32
method is called with arguments
byteOffset
and
value
and optional argument
littleEndian
, the following steps are taken:
"Float32"
,
value
).
When the
setFloat64
method is called with arguments
byteOffset
and
value
and optional argument
littleEndian
, the following steps are taken:
"Float64"
,
value
).
When the
setInt8
method is called with arguments
byteOffset
and
value
, the following steps are taken:
"Int8"
,
value
).
When the
setInt16
method is called with arguments
byteOffset
and
value
and optional argument
littleEndian
, the following steps are taken:
"Int16"
,
value
).
When the
setInt32
method is called with arguments
byteOffset
and
value
and optional argument
littleEndian
, the following steps are taken:
"Int32"
,
value
).
When the
setUint8
method is called with arguments
byteOffset
and
value
, the following steps are taken:
"Uint8"
,
value
).
When the
setUint16
method is called with arguments
byteOffset
and
value
and optional argument
littleEndian
, the following steps are taken:
"Uint16"
,
value
).
When the
setUint32
method is called with arguments
byteOffset
and
value
and optional argument
littleEndian
, the following steps are taken:
"Uint32"
,
value
).
The initial value of the @@toStringTag property is the String value
"DataView"
.
This property has the attributes { [[Writable]]:
DataView instances are ordinary objects that inherit properties from the DataView prototype object. DataView instances each have [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], and [[ByteOffset]] internal slots.
The value of the [[DataView]] internal slot is not used
within this specification. The simple presence of that internal slot is
used within the specification to identify objects created using the
DataView
The Atomics object:
Atomics
property of the
new
operator.
The Atomics object provides functions that operate indivisibly
(atomically) on shared memory array cells as well as functions that let
agents wait for and dispatch primitive events. When used with
discipline, the Atomics functions allow multi-
For informative guidelines for programming and implementing shared memory in ECMAScript, please see the notes at the end of the
The abstract operation ValidateSharedIntegerTypedArray takes one argument typedArray and an optional Boolean onlyInt32 . It performs the following steps:
"Int32Array"
, throw a
"Int8Array"
,
"Uint8Array"
,
"Int16Array"
,
"Uint16Array"
,
"Int32Array"
, or
"Uint32Array"
, throw a
The abstract operation ValidateAtomicAccess takes two arguments, typedArray and requestIndex . It performs the following steps:
A
WaiterList
is a semantic object that contains an ordered list of those agents that are waiting on a location (
block
,
i
) in shared memory;
block
is a
The
Operations on a WaiterList -- adding and removing waiting agents, traversing the list of agents, suspending and notifying agents on the list -- may only be performed by agents that have entered the WaiterList's critical section.
The abstract operation GetWaiterList takes two arguments, a
The abstract operation EnterCriticalSection takes one argument, a
The abstract operation LeaveCriticalSection takes one argument, a
The abstract operation AddWaiter takes two arguments, a
The abstract operation RemoveWaiter takes two arguments, a
The abstract operation RemoveWaiters takes two arguments, a
The abstract operation Suspend takes three arguments, a
The abstract operation NotifyWaiter takes two arguments, a
The embedding may delay notifying W , e.g. for resource management reasons, but W must eventually be notified in order to guarantee forward progress.
The abstract operation AtomicReadModifyWrite takes four arguments,
typedArray
,
index
,
value
, and a pure combining operation
op
. The pure combining operation
op
takes two
The abstract operation AtomicLoad takes two arguments, typedArray , index . The operation atomically loads a value and returns the loaded value. It performs the following steps:
"SeqCst"
).
Let
add
denote a semantic function of two
The following steps are taken:
add
).
Let
and
denote a semantic function of two
The following steps are taken:
and
).
The following steps are taken:
compareExchange
denote a semantic function of two
compareExchange
).
Let
second
denote a semantic function of two
The following steps are taken:
second
).
The following steps are taken:
Atomics.isLockFree
() is an optimization primitive. The intuition is that if the atomic step of an atomic primitive (
compareExchange
,
load
,
store
,
add
,
sub
,
and
,
or
,
xor
, or
exchange
) on a datum of size
n
bytes will be performed without the calling
Atomics.isLockFree
(
n
) will return
Atomics.isLockFree
(4) always returns
The following steps are taken:
Let
or
denote a semantic function of two
The following steps are taken:
or
).
The following steps are taken:
"SeqCst"
).
Let
subtract
denote a semantic function of two
The following steps are taken:
subtract
).
Atomics.wait
puts the calling
"not-equal"
.
"ok"
.
"timed-out"
.
Atomics.notify
notifies some agents that are sleeping in the wait queue. The following steps are taken:
Let
xor
denote a semantic function of two
The following steps are taken:
xor
).
The initial value of the @@toStringTag property is the String value
"Atomics"
.
This property has the attributes { [[Writable]]:
The JSON object:
JSON
property of the
parse
and
stringify
, that are used to parse and construct JSON texts.
new
operator.
The JSON Data Interchange Format is defined in ECMA-404. The JSON
interchange format used in this specification is exactly that described
by ECMA-404. Conforming implementations of
JSON.parse
and
JSON.stringify
must support the exact interchange format described in the ECMA-404
specification without any deletions or extensions to the format.
The
parse
function parses a JSON text (a
JSON-formatted String) and produces an ECMAScript value. The JSON format
represents literals, arrays, and objects with a syntax similar to the
syntax for ECMAScript literals, Array Initializers, and Object
Initializers. After parsing, JSON objects are realized as ECMAScript
objects. JSON arrays are realized as ECMAScript Array instances. JSON
strings, numbers, booleans, and null are realized as ECMAScript Strings,
Numbers, Booleans, and
The optional
reviver
parameter is a function that takes two parameters,
key
and
value
. It can filter and transform the results. It is called with each of the
key
/
value
pairs produced by the parse, and its return value is used instead of
the original value. If it returns what it received, the structure is not
modified. If it returns
"("
,
JText
, and
");"
.
This function is the %JSONParse% intrinsic object.
The
"length"
property of the
parse
function is 2.
Valid JSON text is a subset of the ECMAScript
The abstract operation InternalizeJSONProperty is a recursive abstract operation that takes two parameters: a holder object and the String name of a property in that object. InternalizeJSONProperty uses the value of reviver that was originally passed to the above parse function.
"length"
)).
It is not permitted for a conforming implementation of
JSON.parse
to extend the JSON grammars. If an implementation wishes to support a
modified or extended JSON interchange format it must do so by defining a
different parse function.
In the case where there are duplicate name Strings within an object, lexically preceding values for the same key shall be overwritten.
The
stringify
function returns a String in UTF-16 encoded JSON format representing an ECMAScript value, or
These are the steps in stringifying an object:
"length"
)).
The
"length"
property of the
stringify
function is 3.
JSON structures are allowed to be nested to any depth, but they must be acyclic. If
value
is or contains a cyclic structure, then the stringify function must throw a
a = [];
a[
0
] = a;
my_text =
JSON
.stringify(a);
// This must throw a TypeError.
Symbolic primitive values are rendered as follows:
null
.
true
.
false
.
String values are wrapped in QUOTATION MARK (
"
) code units. The code units
"
and
\
are escaped with
\
prefixes. Control characters code units are replaced with escape sequences
\u
HHHH, or with the shorter forms,
\b
(BACKSPACE),
\f
(FORM FEED),
\n
(LINE FEED),
\r
(CARRIAGE RETURN),
\t
(CHARACTER TABULATION).
Finite numbers are stringified as if by calling
null
.
Values that do not have a JSON representation (such as
null
. In objects an unrepresentable value causes the property to be excluded from stringification.
An object is rendered as U+007B (LEFT CURLY BRACKET) followed
by zero or more properties, separated with a U+002C (COMMA), closed
with a U+007D (RIGHT CURLY BRACKET). A property is a quoted String
representing the key or
The abstract operation SerializeJSONProperty with arguments
key
, and
holder
has access to
ReplacerFunction
from the invocation of the
stringify
method. Its algorithm is as follows:
"toJSON"
).
"null"
.
"true"
.
"false"
.
"null"
.
The abstract operation QuoteJSONString with argument value wraps a String value in QUOTATION MARK code units and escapes certain other code units within it.
This operation interprets a String value as a sequence of UTF-16 encoded code points, as described in
| Code Point | Unicode Character Name | Escape Sequence |
|---|---|---|
| U+0008 | BACKSPACE |
\b
|
| U+0009 | CHARACTER TABULATION |
\t
|
| U+000A | LINE FEED (LF) |
\n
|
| U+000C | FORM FEED (FF) |
\f
|
| U+000D | CARRIAGE RETURN (CR) |
\r
|
| U+0022 | QUOTATION MARK |
\"
|
| U+005C | REVERSE SOLIDUS |
\\
|
The abstract operation UnicodeEscape takes a code unit argument C and represents it as a Unicode escape sequence.
"u"
The abstract operation SerializeJSONObject with argument
value
serializes an object. It has access to the
stack
,
indent
,
gap
, and
PropertyList
values of the current invocation of the
stringify
method.
":"
.
"{}"
.
"{"
,
properties
, and
"}"
.
"{"
, the code unit 0x000A (LINE FEED),
indent
,
properties
, the code unit 0x000A (LINE FEED),
stepback
, and
"}"
.
The abstract operation SerializeJSONArray with argument
value
serializes an array. It has access to the
stack
,
indent
, and
gap
values of the current invocation of the
stringify
method.
"length"
)).
"null"
to
partial
.
"[]"
.
"["
,
properties
, and
"]"
.
"["
, the code unit 0x000A (LINE FEED),
indent
,
properties
, the code unit 0x000A (LINE FEED),
stepback
, and
"]"
.
The representation of arrays includes only the elements between zero and
array.length
- 1
The initial value of the @@toStringTag property is the String value
"JSON"
.
This property has the attributes { [[Writable]]:
An interface is a set of property keys whose associated values match a specific specification. Any object that provides all the properties as described by an interface's specification conforms to that interface. An interface is not represented by a distinct object. There may be many separately implemented objects that conform to any interface. An individual object may conform to multiple interfaces.
The
Iterable
interface includes the property described in
| Property | Value | Requirements |
|---|---|---|
@@iterator
|
A function that returns an Iterator object. | The returned object must conform to the Iterator interface. |
An object that implements the
Iterator
interface must include the property in
| Property | Value | Requirements |
|---|---|---|
next
|
A function that returns an IteratorResult object. |
The returned object must conform to the
IteratorResult
interface. If a previous call to the
next
method of an
Iterator
has returned an
IteratorResult
object whose
done
property is
next
method of that object should also return an
IteratorResult
object whose
done
property is
|
Arguments may be passed to the next function but their interpretation and validity is dependent upon the target Iterator . The for-of statement and other common users of Iterators do not pass any arguments, so Iterator objects that expect to be used in such a manner must be prepared to deal with being called with no arguments.
| Property | Value | Requirements |
|---|---|---|
return
|
A function that returns an IteratorResult object. |
The returned object must conform to the
IteratorResult
interface. Invoking this method notifies the
Iterator
object that the caller does not intend to make any more
next
method calls to the
Iterator
. The returned
IteratorResult
object will typically have a
done
property whose value is
value
property with the value passed as the argument of the
return
method. However, this requirement is not enforced.
|
throw
|
A function that returns an IteratorResult object. |
The returned object must conform to the
IteratorResult
interface. Invoking this method notifies the
Iterator
object that the caller has detected an error condition. The argument
may be used to identify the error condition and typically will be an
exception object. A typical response is to
throw
the value passed as the argument. If the method does not
throw
, the returned
IteratorResult
object will typically have a
done
property whose value is
|
Typically callers of these methods should check for their
existence before invoking them. Certain ECMAScript language features
including
for
-
of
,
yield*
, and
array destructuring call these methods after performing an existence
check. Most ECMAScript library functions that accept
Iterable
objects as arguments also conditionally call them.
The
AsyncIterable
interface includes the properties described in
| Property | Value | Requirements |
|---|---|---|
@@asyncIterator
|
A function that returns an AsyncIterator object. | The returned object must conform to the AsyncIterator interface. |
An object that implements the
AsyncIterator
interface must include the properties in
| Property | Value | Requirements |
|---|---|---|
next
|
A function that returns a promise for an IteratorResult object. |
The returned promise, when fulfilled, must fulfill with an object which conforms to the
IteratorResult
interface. If a previous call to the
Additionally, the
IteratorResult
object that serves as a fulfillment value should have a
|
Arguments may be passed to the next function but their interpretation and validity is dependent upon the target
AsyncIterator
. The
for
-
await
-
of
statement and other common users of
AsyncIterators
do not pass any arguments, so
AsyncIterator
objects that expect to be used in such a manner must be prepared to deal with being called with no arguments.
| Property | Value | Requirements |
|---|---|---|
return
|
A function that returns a promise for an IteratorResult object. |
The returned promise, when fulfilled, must fulfill with an object which conforms to the
IteratorResult
interface. Invoking this method notifies the
AsyncIterator
object that the caller does not intend to make any more
Additionally, the
IteratorResult
object that serves as a fulfillment value should have a
|
throw
|
A function that returns a promise for an IteratorResult object. |
The returned promise, when fulfilled, must fulfill with an object which conforms to the IteratorResult interface. Invoking this method notifies the AsyncIterator object that the caller has detected an error condition. The argument may be used to identify the error condition and typically will be an exception object. A typical response is to return a rejected promise which rejects with the value passed as the argument.
If the returned promise is fulfilled, the
IteratorResult
fulfillment value will typically have a
|
Typically callers of these methods should check for their
existence before invoking them. Certain ECMAScript language features
including
for
-
await
-
of
and
yield*
call these methods after performing an existence check.
The
IteratorResult
interface includes the properties listed in
| Property | Value | Requirements |
|---|---|---|
done
|
Either
|
This is the result status of an
iterator
next
method call. If the end of the iterator was reached
done
is
done
is
done
property (either own or inherited) does not exist, it is consider to have the value
|
value
|
Any
|
If done is
value
is
value
property may be absent from the conforming object if it does not inherit an explicit
value
property.
|
The %IteratorPrototype% object:
All objects defined in this specification that implement the Iterator interface also inherit from %IteratorPrototype%. ECMAScript code may also define objects that inherit from %IteratorPrototype%.The %IteratorPrototype% object provides a place where additional methods that are applicable to all iterator objects may be added.
The following expression is one way that ECMAScript code can access the %IteratorPrototype% object:
Object
.getPrototypeOf(
Object
.getPrototypeOf([][
Symbol
.iterator]()))
The following steps are taken:
The value of the
name
property of this function is
"[Symbol.iterator]"
.
The %AsyncIteratorPrototype% object:
All objects defined in this specification that implement the AsyncIterator interface also inherit from %AsyncIteratorPrototype%. ECMAScript code may also define objects that inherit from %AsyncIteratorPrototype%.The %AsyncIteratorPrototype% object provides a place where additional methods that are applicable to all async iterator objects may be added.
The following steps are taken:
The value of the
name
property of this function is
"[Symbol.asyncIterator]"
.
An Async-from-Sync Iterator object is an async iterator that adapts a specific synchronous iterator. There is not a named
The abstract operation CreateAsyncFromSyncIterator is used to create an async iterator
The %AsyncFromSyncIteratorPrototype% object:
"return"
).
"throw"
).
The initial value of the @@toStringTag property is the String value
"Async-from-Sync Iterator"
.
This property has the attributes { [[Writable]]:
An async-from-sync iterator value unwrap function is an anonymous built-in function that is used by methods of
value
field of an
IteratorResult
object, in order to wait for its value if it is a promise and re-package the result in a new "unwrapped"
IteratorResult
object. Each async iterator value unwrap function has a [[Done]] internal slot.
When an async-from-sync iterator value unwrap function is called with argument value , the following steps are taken:
Async-from-Sync Iterator instances are ordinary objects that inherit properties from the
| Internal Slot | Description |
|---|---|
| [[SyncIteratorRecord]] |
A
|
GeneratorFunction objects are functions that are usually created by evaluating
The GeneratorFunction
GeneratorFunction (…)
is equivalent to the object creation expression
new GeneratorFunction (…)
with the same arguments.
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
GeneratorFunction
behaviour must include a
super
call to the
GeneratorFunction
GeneratorFunction
. There is no syntactic means to create instances of
GeneratorFunction
subclasses.
The last argument specifies the body (executable code) of a generator function; any preceding arguments specify formal parameters.
When the
GeneratorFunction
function is called with some arguments
p1
,
p2
, … ,
pn
,
body
(where
n
might be 0, that is, there are no “
p
” arguments, and where
body
might also not be provided), the following steps are taken:
"generator"
,
args
).
See NOTE for
The GeneratorFunction
Function
name
property whose value is
"GeneratorFunction"
.
This is a
The initial value of
GeneratorFunction.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The GeneratorFunction prototype object:
prototype
property of the intrinsic object
The initial value of
GeneratorFunction.prototype.constructor
is the intrinsic object
This property has the attributes { [[Writable]]:
The value of
GeneratorFunction.prototype.prototype
is the
This property has the attributes { [[Writable]]:
The initial value of the @@toStringTag property is the String value
"GeneratorFunction"
.
This property has the attributes { [[Writable]]:
Every GeneratorFunction instance is an ECMAScript
"generator"
.
Each GeneratorFunction instance has the following own properties:
The specification for the
"length"
property of Function instances given in
The specification for the
name
property of Function instances given in
Whenever a GeneratorFunction instance is created another
ordinary object is also created and is the initial value of the
generator function's
prototype
property. The value of the
prototype property is used to initialize the [[Prototype]] internal slot
of a newly created Generator object when the generator
This property has the attributes { [[Writable]]:
Unlike Function instances, the object that is the value of the a GeneratorFunction's
prototype
property does not have a
constructor
property whose value is the GeneratorFunction instance.
AsyncGeneratorFunction objects are functions that are usually created by evaluating
The AsyncGeneratorFunction
AsyncGeneratorFunction (...)
is equivalent to the object creation expression
new AsyncGeneratorFunction (...)
with the same arguments.
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
AsyncGeneratorFunction
behaviour must include a
super
call to the
AsyncGeneratorFunction
AsyncGeneratorFunction
. There is no syntactic means to create instances of
AsyncGeneratorFunction
subclasses.
The last argument specifies the body (executable code) of an async generator function; any preceding arguments specify formal parameters.
When the
AsyncGeneratorFunction
function is called with some arguments
p1
,
p2
, … ,
pn
,
body
(where
n
might be 0, that is, there are no "
p
" arguments, and where
body
might also not be provided), the following steps are taken:
"async generator"
,
args
).
See NOTE for
The AsyncGeneratorFunction
Function
name
property whose value is
"AsyncGeneratorFunction"
.
This is a
The initial value of
AsyncGeneratorFunction.prototype
is the intrinsic object
%AsyncGenerator%
.
This property has the attributes { [[Writable]]:
The AsyncGeneratorFunction prototype object:
prototype
property of the intrinsic object
The initial value of
AsyncGeneratorFunction.prototype.constructor
is the intrinsic object
This property has the attributes { [[Writable]]:
The value of
AsyncGeneratorFunction.prototype.prototype
is the
This property has the attributes { [[Writable]]:
The initial value of the @@toStringTag property is the String value
"AsyncGeneratorFunction"
.
This property has the attributes { [[Writable]]:
Every AsyncGeneratorFunction instance is an ECMAScript
"generator"
.
Each AsyncGeneratorFunction instance has the following own properties:
The value of the
"length"
property is an integer
that indicates the typical number of arguments expected by the
AsyncGeneratorFunction. However, the language permits the function to be
invoked with some other number of arguments. The behaviour of an
AsyncGeneratorFunction when invoked on a number of arguments other than
the number specified by its
"length"
property depends on the function.
This property has the attributes { [[Writable]]:
The specification for the
name
property of Function instances given in
Whenever an AsyncGeneratorFunction instance is created
another ordinary object is also created and is the initial value of the
async generator function's
prototype
property. The value of
the prototype property is used to initialize the [[Prototype]] internal
slot of a newly created AsyncGenerator object when the generator
This property has the attributes { [[Writable]]:
Unlike function instances, the object that is the value of the an AsyncGeneratorFunction's
prototype
property does not have a
constructor
property whose value is the AsyncGeneratorFunction instance.
A Generator object is an instance of a generator function and conforms to both the Iterator and Iterable interfaces.
Generator instances directly inherit properties from the object that is the value of the
prototype
property of the Generator function that created the instance. Generator
instances indirectly inherit properties from the Generator Prototype
intrinsic,
The Generator prototype object:
prototype
property of the intrinsic object
The initial value of
Generator.prototype.constructor
is the intrinsic object
This property has the attributes { [[Writable]]:
The
next
method performs the following steps:
The
return
method performs the following steps:
The
throw
method performs the following steps:
The initial value of the @@toStringTag property is the String value
"Generator"
.
This property has the attributes { [[Writable]]:
Generator instances are initially created with the internal slots described in
| Internal Slot | Description |
|---|---|
| [[GeneratorState]] |
The current execution state of the generator. The possible values are:
"suspendedStart"
,
"suspendedYield"
,
"executing"
, and
"completed"
.
|
| [[GeneratorContext]] |
The
|
The abstract operation GeneratorStart with arguments generator and generatorBody performs the following steps:
"completed"
.
"completed"
state it never leaves it and its associated
"suspendedStart"
.
The abstract operation GeneratorValidate with argument generator performs the following steps:
"executing"
, throw a
The abstract operation GeneratorResume with arguments generator and value performs the following steps:
"completed"
, return
"suspendedStart"
or
"suspendedYield"
.
"executing"
.
The abstract operation GeneratorResumeAbrupt with arguments generator and abruptCompletion performs the following steps:
"suspendedStart"
, then
"completed"
.
"completed"
state it never leaves it and its associated
"completed"
.
"completed"
, then
"suspendedYield"
.
"executing"
.
The abstract operation GeneratorYield with argument iterNextObj performs the following steps:
"suspendedYield"
.
An AsyncGenerator object is an instance of an async generator function and conforms to both the AsyncIterator and AsyncIterable interfaces.
AsyncGenerator instances directly inherit properties from the object that is the value of the
prototype
property of the AsyncGenerator function that created the instance.
AsyncGenerator instances indirectly inherit properties from the
AsyncGenerator Prototype intrinsic,
The AsyncGenerator prototype object:
prototype
property of the intrinsic object
The initial value of
AsyncGenerator.prototype.constructor
is the intrinsic object
This property has the attributes { [[Writable]]:
The initial value of the @@toStringTag property is the String value
"AsyncGenerator"
.
This property has the attributes { [[Writable]]:
AsyncGenerator instances are initially created with the internal slots described below:
| Internal Slot | Description |
|---|---|
| [[AsyncGeneratorState]] |
The current execution state of the async generator. The possible values are:
"suspendedStart"
,
"suspendedYield"
,
"executing"
,
"awaiting-return"
, and
"completed"
.
|
| [[AsyncGeneratorContext]] |
The
|
| [[AsyncGeneratorQueue]] |
A
|
The AsyncGeneratorRequest is a
They have the following fields:
| Field Name | Value | Meaning |
|---|---|---|
| [[Completion]] |
A
|
The completion which should be used to resume the async generator. |
| [[Capability]] | A PromiseCapability record | The promise capabilities associated with this request. |
"completed"
.
"suspendedStart"
.
"executing"
.
"awaiting-return"
, return
"suspendedStart"
, then
"completed"
.
"completed"
.
"completed"
, then
"awaiting-return"
.
"completed"
, return !
"suspendedStart"
or
"suspendedYield"
.
"executing"
.
An
When an
"completed"
.
The
"length"
property of an
An
When an
"completed"
.
The
"length"
property of an
"executing"
, then
The abstract operation AsyncGeneratorYield with argument value performs the following steps:
"suspendedYield"
.
A Promise is an object that is used as a placeholder for the eventual results of a deferred (and possibly asynchronous) computation.
Any Promise object is in one of three mutually exclusive states: fulfilled , rejected , and pending :
p
is fulfilled if
p.then(f, r)
will immediately enqueue a Job to call the function
f
.
p
is rejected if
p.then(f, r)
will immediately enqueue a Job to call the function
r
.
A promise is said to be settled if it is not pending, i.e. if it is either fulfilled or rejected.
A promise is resolved if it is settled or if it has been “locked in” to match the state of another promise. Attempting to resolve or reject a resolved promise has no effect. A promise is unresolved if it is not resolved. An unresolved promise is always in the pending state. A resolved promise may be pending, fulfilled or rejected.
A PromiseCapability is a
PromiseCapability Records have the fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[Promise]] | An object | An object that is usable as a promise. |
| [[Resolve]] |
A
|
The function that is used to resolve the given promise object. |
| [[Reject]] |
A
|
The function that is used to reject the given promise object. |
IfAbruptRejectPromise is a shorthand for a sequence of algorithm steps that use a PromiseCapability
means the same thing as:
The PromiseReaction is a
PromiseReaction records have the fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[Capability]] |
A PromiseCapability
|
The capabilities of the promise for which this record provides a reaction handler. |
| [[Type]] |
Either
"Fulfill"
or
"Reject"
.
|
The [[Type]] is used when [[Handler]] is
|
| [[Handler]] |
A
|
The function that should be applied to the incoming
value, and whose return value will govern what happens to the derived
promise. If [[Handler]] is
|
When CreateResolvingFunctions is performed with argument promise , the following steps are taken:
A promise reject function is an anonymous built-in function that has [[Promise]] and [[AlreadyResolved]] internal slots.
When a promise reject function is called with argument reason , the following steps are taken:
The
"length"
property of a promise reject function is 1.
A promise resolve function is an anonymous built-in function that has [[Promise]] and [[AlreadyResolved]] internal slots.
When a promise resolve function is called with argument resolution , the following steps are taken:
"then"
).
"PromiseJobs"
,
The
"length"
property of a promise resolve function is 1.
When the FulfillPromise abstract operation is called with arguments promise and value , the following steps are taken:
"pending"
.
"fulfilled"
.
The abstract operation NewPromiseCapability takes a
Promise
Promise
This abstract operation supports Promise subclassing, as it is generic on any
A GetCapabilitiesExecutor function is an anonymous built-in function that has a [[Capability]] internal slot.
When a GetCapabilitiesExecutor function is called with arguments resolve and reject , the following steps are taken:
The
"length"
property of a GetCapabilitiesExecutor function is 2.
The abstract operation IsPromise checks for the promise brand on an object.
When the RejectPromise abstract operation is called with arguments promise and reason , the following steps are taken:
"pending"
.
"rejected"
.
"reject"
).
The abstract operation TriggerPromiseReactions takes a
collection of PromiseReactionRecords and enqueues a new Job for each
record. Each such Job processes the [[Type]] and [[Handler]] of the
PromiseReactionRecord, and if the [[Handler]] is a function, calls it
passing the given argument. If the [[Handler]] is
"PromiseJobs"
,
HostPromiseRejectionTracker is an implementation-defined abstract operation that allows host environments to track promise rejections.
An implementation of HostPromiseRejectionTracker must complete normally in all cases. The default implementation of HostPromiseRejectionTracker is to unconditionally return an empty normal completion.
HostPromiseRejectionTracker is called in two scenarios:
"reject"
.
"handle"
.
A typical implementation of HostPromiseRejectionTracker might try to notify developers of unhandled rejections, while also being careful to notify them if such previous notifications are later invalidated by new handlers being attached.
If
operation
is
"handle"
, an implementation should not hold a reference to
promise
in a way that would interfere with garbage collection. An implementation may hold a reference to
promise
if
operation
is
"reject"
, since it is expected that rejections will be rare and not on hot code paths.
The job PromiseReactionJob with parameters reaction and argument applies the appropriate handler to the incoming value, and uses the handler's return value to resolve or reject the derived promise associated with that handler.
"Fulfill"
, let
handlerResult
be
"Reject"
.
The job PromiseResolveThenableJob with parameters promiseToResolve , thenable , and then performs the following steps:
This Job uses the supplied thenable and its
then
method to resolve the given promise. This process must take place as a Job to ensure that the evaluation of the
then
method occurs after evaluation of any surrounding code has completed.
The Promise
Promise
property of the
extends
clause of a class definition. Subclass constructors that intend to inherit the specified
Promise
behaviour must include a
super
call to the
Promise
Promise
and
Promise.prototype
built-in methods.
When the
Promise
function is called with argument
executor
, the following steps are taken:
"%PromisePrototype%"
, « [[PromiseState]], [[PromiseResult]], [[PromiseFulfillReactions]], [[PromiseRejectReactions]], [[PromiseIsHandled]] »).
"pending"
.
The
executor
argument must be a
The resolve function that is passed to an executor function accepts a single argument. The executor code may eventually call the resolve function to indicate that it wishes to resolve the associated Promise object. The argument passed to the resolve function represents the eventual value of the deferred action and can be either the actual fulfillment value or another Promise object which will provide the value if it is fulfilled.
The
reject
function that is passed to an
executor
function accepts a single argument. The
executor
code may eventually call the
reject
function to indicate that the associated Promise is rejected and will never be fulfilled. The argument passed to the
reject
function is used as the rejection value of the promise. Typically it will be an
Error
object.
The resolve and reject functions passed to an
executor
function by the Promise
The Promise
The
all
function returns a new promise which is
fulfilled with an array of fulfillment values for the passed promises,
or rejects with the reason of the first passed promise that rejects. It
resolves all elements of the passed iterable to promises as it runs this
algorithm.
This function is the %Promise_all% intrinsic object.
The
all
function requires its
Promise
When the PerformPromiseAll abstract operation is called with arguments iteratorRecord , constructor , and resultCapability , the following steps are taken:
"resolve"
, «
nextValue
»).
Promise.all
Resolve Element Functions
"then"
, «
resolveElement
,
resultCapability
.[[Reject]] »).
Promise.all
Resolve Element Functions
A
Promise.all
resolve element function is an anonymous built-in function that is used to resolve a specific
Promise.all
element. Each
Promise.all
resolve element function has [[Index]], [[Values]], [[Capability]],
[[RemainingElements]], and [[AlreadyCalled]] internal slots.
When a
Promise.all
resolve element function is called with argument
x
, the following steps are taken:
The
"length"
property of a
Promise.all
resolve element function is 1.
The initial value of
Promise.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The
race
function returns a new promise which is
settled in the same way as the first passed promise to settle. It
resolves all elements of the passed
iterable
to promises as it runs this algorithm.
If the iterable argument is empty or if none of the promises in iterable ever settle then the pending promise returned by this method will never be settled.
The
race
function expects its
Promise
resolve
method.
When the PerformPromiseRace abstract operation is called with arguments iteratorRecord , constructor , and resultCapability , the following steps are taken:
"resolve"
, «
nextValue
»).
"then"
, «
resultCapability
.[[Resolve]],
resultCapability
.[[Reject]] »).
The
reject
function returns a new promise rejected with the passed argument.
This function is the %Promise_reject% intrinsic object.
The
reject
function expects its
Promise
The
resolve
function returns either a new
promise resolved with the passed argument, or the argument itself if the
argument is a promise produced by this
This function is the %Promise_resolve% intrinsic object.
The
resolve
function expects its
Promise
The abstract operation PromiseResolve, given a
Promise[@@species]
is an
The value of the
name
property of this function is
"get [Symbol.species]"
.
Promise prototype methods normally use their
this
object's
The Promise prototype object:
When the
catch
method is called with argument
onRejected
, the following steps are taken:
"then"
, «
The initial value of
Promise.prototype.constructor
is the intrinsic object
When the
finally
method is called with argument
onFinally
, the following steps are taken:
"then"
, «
thenFinally
,
catchFinally
»).
A Then Finally function is an anonymous built-in function
that has a [[Constructor]] and an [[OnFinally]] internal slot. The value
of the [[Constructor]] internal slot is a
Promise
-like
When a Then Finally function is called with argument value , the following steps are taken:
"then"
, «
valueThunk
»).
The
"length"
property of a Then Finally function is
A Catch Finally function is an anonymous built-in function
that has a [[Constructor]] and an [[OnFinally]] internal slot. The value
of the [[Constructor]] internal slot is a
Promise
-like
When a Catch Finally function is called with argument reason , the following steps are taken:
"then"
, «
thrower
»).
The
"length"
property of a Catch Finally function is
When the
then
method is called with arguments
onFulfilled
and
onRejected
, the following steps are taken:
This function is the %PromiseProto_then% intrinsic object.
The abstract operation PerformPromiseThen performs the “then” operation on promise using onFulfilled and onRejected as its settlement actions. If resultCapability is passed, the result is stored by updating resultCapability 's promise. (If it is not passed, then PerformPromiseThen is being called by a specification-internal operation where the result does not matter.)
"Fulfill"
, [[Handler]]:
onFulfilled
}.
"Reject"
, [[Handler]]:
onRejected
}.
"pending"
, then
"fulfilled"
, then
"PromiseJobs"
,
"rejected"
.
"handle"
).
"PromiseJobs"
,
The initial value of the @@toStringTag property is the String value
"Promise"
.
This property has the attributes { [[Writable]]:
Promise instances are ordinary objects that inherit properties from the Promise prototype object (the intrinsic,
| Internal Slot | Description |
|---|---|
| [[PromiseState]] |
A String value that governs how a promise will react to incoming calls to its
then
method. The possible values are:
"pending"
,
"fulfilled"
, and
"rejected"
.
|
| [[PromiseResult]] |
The value with which the promise has been fulfilled or
rejected, if any. Only meaningful if [[PromiseState]] is not
"pending"
.
|
| [[PromiseFulfillReactions]] |
A
"pending"
state to the
"fulfilled"
state.
|
| [[PromiseRejectReactions]] |
A
"pending"
state to the
"rejected"
state.
|
| [[PromiseIsHandled]] | A boolean indicating whether the promise has ever had a fulfillment or rejection handler; used in unhandled rejection tracking. |
AsyncFunction objects are functions that are usually created by evaluating
The AsyncFunction
Function
.
AsyncFunction(…)
is equivalent to the object creation expression
new AsyncFunction(…)
with the same arguments.
extends
clause of a class definition. Subclass constructors that intend to
inherit the specified AsyncFunction behaviour must include a
super
call to the
AsyncFunction
The last argument specifies the body (executable code) of an async function. Any preceding arguments specify formal parameters.
When the
AsyncFunction
function is called with some arguments
p1
,
p2
, …,
pn
,
body
(where
n
might be 0, that is, there are no
p
arguments, and where
body
might also not be provided), the following steps are taken:
"async"
,
args
).
The AsyncFunction
Function
name
property whose value is
"AsyncFunction"
.
This is a
The initial value of
AsyncFunction.prototype
is the intrinsic object
This property has the attributes { [[Writable]]:
The AsyncFunction prototype object:
prototype
property of the intrinsic object
The initial value of
AsyncFunction.prototype.constructor
is the intrinsic object
This property has the attributes { [[Writable]]:
The initial value of the @@toStringTag property is the string value
"AsyncFunction"
.
This property has the attributes { [[Writable]]:
Every AsyncFunction instance is an ECMAScript
"async"
.
AsyncFunction instances are not constructors and do not have a
[[Construct]] internal method. AsyncFunction instances do not have a
prototype property as they are not constructable.
Each AsyncFunction instance has the following own properties:
The specification for the
"length"
property of Function instances given in
The specification for the
name
property of Function instances given in
The Reflect object:
Reflect
property of the
new
operator.
When the
apply
function is called with arguments
target
,
thisArgument
, and
argumentsList
, the following steps are taken:
When the
construct
function is called with arguments
target
,
argumentsList
, and
newTarget
, the following steps are taken:
When the
defineProperty
function is called with arguments
target
,
propertyKey
, and
attributes
, the following steps are taken:
When the
deleteProperty
function is called with arguments
target
and
propertyKey
, the following steps are taken:
When the
get
function is called with arguments
target
,
propertyKey
, and
receiver
, the following steps are taken:
When the
getOwnPropertyDescriptor
function is called with arguments
target
and
propertyKey
, the following steps are taken:
When the
getPrototypeOf
function is called with argument
target
, the following steps are taken:
When the
has
function is called with arguments
target
and
propertyKey
, the following steps are taken:
When the
isExtensible
function is called with argument
target
, the following steps are taken:
When the
ownKeys
function is called with argument
target
, the following steps are taken:
When the
preventExtensions
function is called with argument
target
, the following steps are taken:
When the
set
function is called with arguments
target
,
V
,
propertyKey
, and
receiver
, the following steps are taken:
When the
setPrototypeOf
function is called with arguments
target
and
proto
, the following steps are taken:
The Proxy
Proxy
property of the
When
Proxy
is called with arguments
target
and
handler
, it performs the following steps:
The Proxy
prototype
property because proxy exotic objects do not have a [[Prototype]] internal slot that requires initialization.
The
Proxy.revocable
function is used to create a revocable Proxy object. When
Proxy.revocable
is called with arguments
target
and
handler
, the following steps are taken:
"proxy"
,
p
).
"revoke"
,
revoker
).
A Proxy revocation function is an anonymous function that has the ability to invalidate a specific Proxy object.
Each Proxy revocation function has a [[RevocableProxy]] internal slot.
When a Proxy revocation function is called, the following steps are taken:
The
"length"
property of a Proxy revocation function is 0.
A Module Namespace Object is a module namespace
In addition to the properties specified in
The initial value of the @@toStringTag property is the String value
"Module"
.
This property has the attributes { [[Writable]]:
The memory consistency model, or
memory model
, specifies the possible orderings of
The memory model is defined as relational constraints on events introduced by
This section provides an axiomatic model on events introduced by the
Shared memory accesses (reads and writes) are divided into two
groups, atomic accesses and data accesses, defined below. Atomic
accesses are sequentially consistent, i.e., there is a strict total
ordering of events agreed upon by all agents in an
No orderings weaker than sequentially consistent and stronger than unordered, such as release-acquire, are supported.
A
Shared Data Block event
is either a
ReadSharedMemory
,
WriteSharedMemory
, or
ReadModifyWriteSharedMemory
| Field Name | Value | Meaning |
|---|---|---|
| [[Order]] |
"SeqCst"
or
"Unordered"
|
The weakest ordering guaranteed by the
|
| [[NoTear]] | A Boolean | Whether this event is allowed to read from multiple write events on equal range as this event. |
| [[Block]] |
A
|
The block the event operates on. |
| [[ByteIndex]] | A nonnegative integer | The byte address of the read in [[Block]]. |
| [[ElementSize]] | A nonnegative integer | The size of the read. |
| Field Name | Value | Meaning |
|---|---|---|
| [[Order]] |
"SeqCst"
,
"Unordered"
, or
"Init"
|
The weakest ordering guaranteed by the
|
| [[NoTear]] | A Boolean | Whether this event is allowed to be read from multiple read events with equal range as this event. |
| [[Block]] |
A
|
The block the event operates on. |
| [[ByteIndex]] | A nonnegative integer | The byte address of the write in [[Block]]. |
| [[ElementSize]] | A nonnegative integer | The size of the write. |
| [[Payload]] |
A
|
The
|
| Field Name | Value | Meaning |
|---|---|---|
| [[Order]] |
"SeqCst"
|
Read-modify-write events are always sequentially consistent. |
| [[NoTear]] |
|
Read-modify-write events cannot tear. |
| [[Block]] |
A
|
The block the event operates on. |
| [[ByteIndex]] | A nonnegative integer | The byte address of the read-modify-write in [[Block]]. |
| [[ElementSize]] | A nonnegative integer | The size of the read-modify-write. |
| [[Payload]] |
A
|
The
|
| [[ModifyOp]] | A semantic function |
A pure semantic function that returns a modified
|
These events are introduced by
Some operations may also introduce Synchronize events. A Synchronize event has no fields, and exists purely to directly constrain the permitted orderings of other events.
In addition to
Let the range of a ReadSharedMemory, WriteSharedMemory, or ReadModifyWriteSharedMemory event be the Set of contiguous integers from its [[ByteIndex]] to [[ByteIndex]] + [[ElementSize]] - 1. Two events' ranges are equal when the events have the same [[Block]], and the ranges are element-wise equal. Two events' ranges are overlapping when the events have the same [[Block]], the ranges are not equal and their intersection is non-empty. Two events' ranges are disjoint when the events do not have the same [[Block]] or their ranges are neither equal nor overlapping.
Examples of host-specific synchronizing events that should be accounted for are: sending a SharedArrayBuffer from one
postMessage
in a browser), starting and stopping agents, and communicating within the
Events are ordered within candidate executions by the relations defined below.
An
Agent Events Record
is a
| Field Name | Value | Meaning |
|---|---|---|
| [[AgentSignifier]] | A value that admits equality testing |
The
|
| [[EventList]] |
A
|
Events are appended to the list during evaluation. |
| [[AgentSynchronizesWith]] |
A
|
|
A
Chosen Value Record
is a
| Field Name | Value | Meaning |
|---|---|---|
| [[Event]] |
A
|
The
|
| [[ChosenValue]] |
A
|
The bytes that were nondeterministically chosen during evaluation. |
A
candidate execution
of the evaluation of an
| Field Name | Value | Meaning |
|---|---|---|
| [[EventsRecords]] |
A
|
Maps an
|
| [[ChosenValues]] |
A
|
Maps
|
| [[AgentOrder]] |
An
|
Defined below. |
| [[ReadsBytesFrom]] |
A
|
Defined below. |
| [[ReadsFrom]] |
A
|
Defined below. |
| [[HostSynchronizesWith]] |
A
|
Defined below. |
| [[SynchronizesWith]] |
A
|
Defined below. |
| [[HappensBefore]] |
A
|
Defined below. |
An
empty candidate execution
is a candidate execution
The abstract operation EventSet takes one argument, a
The abstract operation SharedDataBlockEventSet takes one argument, a
The abstract operation SynchronizeEventSet takes one argument, a
The abstract operation HostEventSet takes one argument, a
The abstract operation ComposeWriteEventBytes takes four arguments, a
The semantic function [[ModifyOp]] is given by the function properties on the Atomics object that introduce
This abstract operation composes a
The abstract operation ValueOfReadEvent takes two arguments, a
For a
Each
For a
For each
For a
For a
For two host-specific events
E
and
D
,
E
host-synchronizes-with
D
implies
E
The host-synchronizes-with relation allows the host to provide additional synchronization mechanisms, such as
postMessage
between HTML workers.
For a
"SeqCst"
.
"SeqCst"
or
"Init"
.
"SeqCst"
, then
R
and
W
have equal ranges.
"Init"
, then for each event
V
such that (
R
,
V
) is in
execution
.[[ReadsFrom]],
V
.[[Order]] is
"Init"
.
Owing to convention, write events synchronizes-with read events, instead of read events synchronizes-with write events.
Not all
"SeqCst"
events related by
For
For a
"Init"
and
E
and
D
have overlapping ranges.
Because happens-before is a superset of
A
A
A
An event's [[NoTear]] field is
Intuitively, this requirement says when a memory range is accessed in an aligned fashion via an integer TypedArray, a single write event on that range must "win" when in a data race with other write events with equal ranges. More precisely, this requirement says an aligned read event cannot read a value composed of bytes from multiple, different write events all with equal ranges. It is possible, however, for an aligned read event to read from multiple write events with overlapping ranges.
For a
For each pair (
E
,
D
) in
execution
.[[SynchronizesWith]], (
E
,
D
) is in memory-order if there is no
This clause additionally constrains
"SeqCst"
events on equal ranges.
For each
"SeqCst"
, then it is not the case that there is an infinite number of
This clause together with the forward progress guarantee on agents ensure the liveness condition that
"SeqCst"
writes become visible to
"SeqCst"
reads with equal range in finite time.
A
While memory-order includes all events in
A
All programs have at least one valid execution.
For an execution
execution
, two events
E
and
D
in
For an execution
execution
, two events
E
and
D
in
"SeqCst"
or
D
.[[Order]] is not
"SeqCst"
, then
An execution
execution
is data race free if there are no two events in
A program is data race free if all its executions are data race free.
The
The following are guidelines for ECMAScript programmers working with shared memory.
We recommend programs be kept data race free, i.e., make it so
that it is impossible for there to be concurrent non-atomic operations
on the same memory location. Data race free programs have interleaving
semantics where each step in the evaluation semantics of each
More generally, even if a program is not data race free it may have predictable behaviour, so long as atomic operations are not involved in any data races and the operations that race all have the same access size. The simplest way to arrange for atomics not to be involved in races is to ensure that different memory cells are used by atomic and non-atomic operations and that atomic accesses of different sizes are not used to access the same cells at the same time. Effectively, the program should treat shared memory as strongly typed as much as possible. One still cannot depend on the ordering and timing of non-atomic accesses that race, but if memory is treated as strongly typed the racing accesses will not "tear" (bits of their values will not be mixed).
The following are guidelines for ECMAScript implementers writing compiler transformations for programs using shared memory.
It is desirable to allow most program transformations that are valid in a single-
Let an
agent-order slice
be the subset of the
Let
possible read values
of a read event be the set of all values of
Any transformation of an agent-order slice that is valid in the absence of shared memory is valid in the presence of shared memory, with the following exceptions.
Atomics are carved in stone
: Program transformations must not cause the
"SeqCst"
events in an agent-order slice to be reordered with its
"Unordered"
operations, nor its
"SeqCst"
operations to be reordered with each other, nor may a program transformation remove a
"SeqCst"
operation from the
(In practice, the prohibition on reorderings forces a compiler to assume that every
"SeqCst"
operation is a synchronization and included in the final
"SeqCst"
operations.)
Reads must be stable : Any given shared memory read must only observe a single value in an execution.
(For example, if what is semantically a single read in the program is executed multiple times then the program is subsequently allowed to observe only one of the values read. A transformation known as rematerialization can violate this rule.)
Writes must be stable : All observable writes to shared memory must follow from program semantics in an execution.
(For example, a transformation may not introduce certain
observable writes, such as by using read-modify-write operations on a
larger location to write a smaller datum, writing a value to memory that
the program could not have written, or writing a just-read value back
to the location it was read from, if that location could have been
overwritten by another
Possible read values must be nonempty : Program transformations cannot cause the possible read values of a shared memory read to become empty.
(Counterintuitively, this rule in effect restricts transformations on writes, because writes have force in
"SeqCst"
operations, but the transformation may not remove every write that updates a location; some write must be preserved.)
Examples of transformations that remain valid are: merging multiple non-atomic reads from the same location, reordering non-atomic reads, introducing speculative non-atomic reads, merging multiple non-atomic writes to the same location, reordering non-atomic writes to different locations, and hoisting non-atomic reads out of loops even if that affects termination. Note in general that aliased TypedArrays make it hard to prove that locations are different.
The following are guidelines for ECMAScript implementers generating machine code for shared memory accesses.
For architectures with memory models no weaker than those of
ARM or Power, non-atomic stores and loads may be compiled to bare stores
and loads on the target architecture. Atomic stores and loads may be
compiled down to instructions that guarantee sequential consistency. If
no such instructions exist, memory barriers are to be employed, such as
placing barriers on both sides of a bare store or load.
Read-modify-write operations may be compiled to read-modify-write
instructions on the target architectrue, such as
LOCK
-prefixed
instructions on x86, load-exclusive/store-exclusive instructions on
ARM, and load-link/store-conditional instructions on Power.
Specifically, the
Naive code generation uses these patterns:
That mapping is correct so long as an atomic operation on an
address range does not race with a non-atomic write or with an atomic
operation of different size. However, that is all we need: the
A number of local improvements to those basic patterns are also intended to be legal:
The following tokens are also considered to be
When processing an instance of the production
When processing an instance of the production
In certain circumstances when processing an instance of the production
When the production
When the production
All grammar symbols not explicitly defined by the
Each
\u
u
u
\u
The ECMAScript language syntax and semantics defined in this annex are required when the ECMAScript host is a web browser. The content of this annex is normative but optional if the ECMAScript host is not a web browser.
This annex describes various legacy features and other characteristics of web browser based ECMAScript implementations. All of the language features and behaviours specified in this annex have one or more undesirable characteristics and in the absence of legacy usage would be removed from this specification. However, the usage of these features by large numbers of existing web pages means that web browsers must continue to support them. The specifications in this annex define the requirements for interoperable implementations of these legacy features.
These features are not considered part of the core ECMAScript language. Programmers should not use or assume the existence of these features and behaviours when writing new ECMAScript code. ECMAScript implementations are discouraged from implementing these features unless the implementation is part of a web browser or is required to run the same legacy ECMAScript code that web browsers encounter.
The syntax and semantics of
The syntax and semantics of
This definition of
The syntax and semantics of
Similar to a
The syntax of
This alternative pattern grammar and semantics only changes the
syntax and semantics of BMP patterns. The following grammar extensions
include productions parameterized with the [U] parameter. However, none
of these extensions change the syntax of Unicode patterns recognized
when parsing with the [U] parameter present on the
When the same left hand sides occurs with both [+U] and [~U] guards it is to control the disambiguation priority.
The semantics of
The semantics of
The semantics of
The semantics of
Within
Term (
The production
The production
The production
Assertion (
The production
Assertion (
Atom (
The production
\
U+005C (REVERSE SOLIDUS).
The production
CharacterEscape (
The production
NonemptyClassRanges (
The production
NonemptyClassRangesNoDash (
The production
ClassEscape (
The production
ClassAtomNoDash (
The production
\
U+005C (REVERSE SOLIDUS).
\c
within a character class where it is not followed by an acceptable control character.
The abstract operation CharacterRangeOrUnion takes two CharSet parameters A and B and performs the following steps:
-
U+002D (HYPHEN-MINUS).
When the ECMAScript host is a web browser the following additional properties of the standard built-in objects are defined.
The entries in
| Intrinsic Name | Global Name | ECMAScript Language Association |
|---|---|---|
|
|
escape
|
The
escape
function (
|
|
|
unescape
|
The
unescape
function (
|
The
escape
function is a property of the
For those code units being replaced whose value is
0x00FF
or less, a two-digit escape sequence of the form
%
xx
is used. For those characters being replaced whose code unit value is greater than
0x00FF
, a four-digit escape sequence of the form
%u
xxxx
is used.
The
escape
function is the
%escape%
intrinsic object. When the
escape
function is called with one argument
string
, the following steps are taken:
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@*_+-./"
, then
"%u"
"%"
The encoding is partly based on the encoding described in RFC 1738, but the entire encoding specified in this standard is described above without regard to the contents of RFC 1738. This encoding does not reflect changes to RFC 1738 made by RFC 3986.
The
unescape
function is a property of the
escape
function is replaced with the code unit that it represents.
The
unescape
function is the
%unescape%
intrinsic object. When the
unescape
function is called with one argument
string
, the following steps are taken:
Object.prototype.__proto__ is an
The value of the [[Get]] attribute is a built-in function that requires no arguments. It performs the following steps:
The value of the [[Set]] attribute is a built-in function that takes an argument proto . It performs the following steps:
When the
__defineGetter__
method is called with arguments
P
and
getter
, the following steps are taken:
When the
__defineSetter__
method is called with arguments
P
and
setter
, the following steps are taken:
When the
__lookupGetter__
method is called with argument
P
, the following steps are taken:
When the
__lookupSetter__
method is called with argument
P
, the following steps are taken:
The
substr
method takes two arguments,
start
and
length
, and returns a substring of the result of converting the
""
.
The
substr
function is intentionally generic; it does not require that its
When the
anchor
method is called with argument
name
, the following steps are taken:
"a"
,
"name"
,
name
).
The abstract operation CreateHTML is called with arguments string , tag , attribute , and value . The arguments tag and attribute must be String values. The following steps are taken:
"<"
and
tag
.
"""
.
">"
.
""
,
tag
, and
">"
.
When the
big
method is called with no arguments, the following steps are taken:
"big"
,
""
,
""
).
When the
blink
method is called with no arguments, the following steps are taken:
"blink"
,
""
,
""
).
When the
bold
method is called with no arguments, the following steps are taken:
"b"
,
""
,
""
).
When the
fixed
method is called with no arguments, the following steps are taken:
"tt"
,
""
,
""
).
When the
fontcolor
method is called with argument
color
, the following steps are taken:
"font"
,
"color"
,
color
).
When the
fontsize
method is called with argument
size
, the following steps are taken:
"font"
,
"size"
,
size
).
When the
italics
method is called with no arguments, the following steps are taken:
"i"
,
""
,
""
).
When the
link
method is called with argument
url
, the following steps are taken:
"a"
,
"href"
,
url
).
When the
small
method is called with no arguments, the following steps are taken:
"small"
,
""
,
""
).
When the
strike
method is called with no arguments, the following steps are taken:
"strike"
,
""
,
""
).
When the
sub
method is called with no arguments, the following steps are taken:
"sub"
,
""
,
""
).
When the
sup
method is called with no arguments, the following steps are taken:
"sup"
,
""
,
""
).
The property
trimStart
is preferred. The
trimLeft
property is provided principally for compatibility with old code. It is recommended that the
trimStart
property be used in new ECMAScript code.
The initial value of the
trimLeft
property is the same
String.prototype.trimStart
property.
The property
trimEnd
is preferred. The
trimRight
property is provided principally for compatibility with old code. It is recommended that the
trimEnd
property be used in new ECMAScript code.
The initial value of the
trimRight
property is the same
String.prototype.trimEnd
property.
The
getFullYear
method is preferred for nearly all purposes, because it avoids the “year 2000 problem.”
When the
getYear
method is called with no arguments, the following steps are taken:
The
setFullYear
method is preferred for nearly all purposes, because it avoids the “year 2000 problem.”
When the
setYear
method is called with one argument
year
, the following steps are taken:
The property
toUTCString
is preferred. The
toGMTString
property is provided principally for compatibility with old code. It is recommended that the
toUTCString
property be used in new ECMAScript code.
The
Date.prototype.toGMTString
is the same
Date.prototype.toUTCString
.
When the
compile
method is called with arguments
pattern
and
flags
, the following steps are taken:
The
compile
method completely reinitializes the
The following Early Error rule is added to those in
"__proto__"
and at least two of those entries were obtained from productions of the form
The
In
is replaced with the following definition:
"__proto__"
and if IsComputedPropertyKey(
Prior to ECMAScript 2015, the specification of
The
Prior to ECMAScript 2015, the ECMAScript specification did not define the occurrence of a
A function is declared and only referenced within a single block
var
declaration occurs within the function code of
g
A function is declared and possibly used within a single
var
declaration occurs within the function code of
g
A function is declared and possibly used within a single block but also referenced within subsequent blocks.
var
declaration occurs within the function code of
g
The first use case is interoperable with the semantics of
ECMAScript 2015 interoperability for the second and third use cases requires the following extensions to the clause
If an ECMAScript implementation has a mechanism for reporting
diagnostic warning messages, a warning should be produced when code
contains a
During
"arguments"
, then
During
During
For web browser compatibility, that rule is modified with the addition of the highlighted text:
switch
Statement Static Semantics: Early Errors
For web browser compatibility, that rule is modified with the addition of the highlighted text:
During
During
The following augments the
This production only applies when parsing
The content of subclause
The
var
declarations that bind a name that is also bound by the
var
declarations will assign to the corresponding catch parameter rather than the
var
binding.
This modified behaviour also applies to
var
and
function
declarations introduced by
Step 5.d.ii.2.a.i is replaced by:
Step 9.d.ii.4.b.i.i is replaced by:
The following augments the
This production only applies when parsing
The
The
The
The
The
The
The
An
[[IsHTMLDDA]] internal slot
may exist on implementation-defined objects. Objects with an [[IsHTMLDDA]] internal slot behave like
typeof
operator
Objects with an [[IsHTMLDDA]] internal slot are never created by this specification. However, the
document.all
object
in web browsers is a host-created
document.all
.
The result column in
The following steps are inserted after step 3 of the
typeof
Operator
The following table entry is inserted into
typeof
| Type of val | Result |
|---|---|
|
Object (has an
|
"undefined"
|
The strict mode restriction and exceptions
implements
,
interface
,
let
,
package
,
private
,
protected
,
public
,
static
, and
yield
are reserved words within
TypeError
exception is thrown (
"eval"
or
"arguments"
may not appear as the
"callee"
which throws a
arguments
to the arguments object is immutable and hence may not be the target of an assignment expression. (
"eval"
or
"arguments"
within
Function.prototype.apply
and
Function.prototype.call
) do not coerce the passed this value to an object (
delete
operator occurs within
delete
operator occurs within
eval
or
arguments
(
Function
,
Generator
, or
AsyncFunction
caller
or
arguments
of function instances.
"z"
.
"Invalid Date"
.
source
property of a RegExp instance must be expressed using an escape sequence. Edition 5.1 only required the escaping of
"/"
.
String.prototype.match
and
String.prototype.replace
was incorrect for cases where the pattern argument was a RegExp value whose
global
is flag set. The previous specifications stated that for each attempt to match the pattern, if
lastIndex
did not change it should be incremented by 1. The correct behaviour is that
lastIndex
should be incremented by one only if the pattern matched the empty string.
Array.prototype.sort
. ECMAScript 2015 specifies that such as value is treated as if
let
followed by the token
[
is the start of a
(
token of a for statement is immediately followed by the token sequence
let [
then the
let
is treated as the start of a
let [
then the
let
is treated as the start of a
in
keyword. In ECMAScript 2015, the
var
declaration for the same
eval
whose eval code includes a
var
or
FunctionDeclaration
declaration that binds the same
prototype
own property. In the previous edition, they were constructors and had a
prototype
property.
Object.freeze
is not an object it is treated as if it was a non-extensible ordinary
object with no own properties. In the previous edition, a non-object
argument always causes a
Object.getOwnPropertyDescriptor
is not an object an attempt is made to coerce the argument using
Object.getOwnPropertyNames
is not an object an attempt is made to coerce the argument using
Object.getPrototypeOf
is not an object an attempt is made to coerce the argument using
Object.isExtensible
is not an object it is treated as if it was a non-extensible ordinary
object with no own properties. In the previous edition, a non-object
argument always causes a
Object.isFrozen
is not an object it is treated as if it was a non-extensible ordinary
object with no own properties. In the previous edition, a non-object
argument always causes a
Object.isSealed
is not an object it is treated as if it was a non-extensible ordinary
object with no own properties. In the previous edition, a non-object
argument always causes a
Object.keys
is not an object an attempt is made to coerce the argument using
Object.preventExtensions
is not an object it is treated as if it was a non-extensible ordinary
object with no own properties. In the previous edition, a non-object
argument always causes a
Object.seal
is not an object it is treated as if it was a non-extensible ordinary
object with no own properties. In the previous edition, a non-object
argument always causes a
"length"
property of function instances is configurable. In previous editions it was non-configurable.
String.prototype.localeCompare
function must treat Strings that are canonically equivalent according
to the Unicode standard as being identical. In previous editions
implementations were permitted to ignore canonical equivalence and could
instead use a bit-wise comparison.
String.prototype.trim
method is defined to recognize white space code points that may exists
outside of the Unicode BMP. However, as of Unicode 7 no such code points
are defined. In previous editions such code points would not have been
recognized as white space.
source
,
global
,
ignoreCase
, and
multiline
are accessor properties defined on the RegExp prototype object. In
previous editions they were data properties defined on RegExp instances.
This specification is authored on GitHub in a plaintext source format called Ecmarkup . Ecmarkup is an HTML and Markdown dialect that provides a framework and toolset for authoring ECMAScript specifications in plaintext and processing the specification into a full-featured HTML rendering that follows the editorial conventions for this document. Ecmarkup builds on and integrates a number of other formats and technologies including Grammarkdown for defining syntax and Ecmarkdown for authoring algorithm steps. PDF renderings of this specification are produced by printing the HTML rendering to a PDF.
Prior editions of this specification were authored using Word—the Ecmarkup source text that formed the basis of this edition was produced by converting the ECMAScript 2015 Word document to Ecmarkup using an automated conversion tool.
Script
Property
, available at <
https://unicode.org/reports/tr24/
>
Ecma International
Rue du Rhone 114
CH-1204 Geneva
Tel: +41 22 849 6000
Fax: +41 22 849 6001
Web: https://ecma-international.org/
© 2019 Ecma International
This document may be copied, published and distributed to others, and certain derivative works of it may be prepared, copied, published, and distributed, in whole or in part, provided that the above copyright notice and this Copyright License and Disclaimer are included on all such copies and derivative works. The only derivative works that are permissible under this Copyright License and Disclaimer are:
(i) works which incorporate all or portion of this document for the purpose of providing commentary or explanation (such as an annotated version of the document),
(ii) works which incorporate all or portion of this document for the purpose of incorporating features that provide accessibility,
(iii) translations of this document into languages other than English and into different formats and
(iv) works by making use of this specification in standard conformant products by implementing (e.g. by copy and paste wholly or partly) the functionality therein.
However, the content of this document itself may not be modified in any way, including by removing the copyright notice or references to Ecma International, except as required to translate it into languages other than English or into a different format.
The official version of an Ecma International document is the English language version on the Ecma International website. In the event of discrepancies between a translated version and the official version, the official version shall govern.
The limited permissions granted above are perpetual and will not be revoked by Ecma International or its successors or assigns.
This document and the information contained herein is provided on an "AS IS" basis and ECMA INTERNATIONAL DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY OWNERSHIP RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
All Software contained in this document ("Software") is protected by copyright and is being made available under the "BSD License", included below. This Software may be subject to third party rights (rights from parties other than Ecma International), including patent rights, and no licenses under such third party rights are granted under this license even if the third party concerned is a member of Ecma International. SEE THE ECMA CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT https://ecma-international.org/memento/codeofconduct.htm FOR INFORMATION REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA INTERNATIONAL STANDARDS.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.